java源代码防破解 java暴力破解代码

如何防止JAVA程序源代码被反编译

我们都知道JAVA是一种解析型语言，这就决定JAVA文件编译后不是机器码，而是一个字节码文件，也就是CLASS文件。而这样的文件是存在规律的，经过反编译工具是可以还原回来的。例如Decafe、FrontEnd，YingJAD和Jode等等软件。下面是《Nokia中Short数组转换算法》

类中Main函数的ByteCode：0 ldc #162 invokestatic #185 astore_16 return其源代码是：short [] pixels = parseImage("/ef1s.png");

我们通过反编译工具是可以还原出以上源代码的。而通过简单的分析，我们也能自己写出源代码的。

第一行：ldc #16

ldc为虚拟机的指令，作用是：压入常量池的项，形式如下ldc index这个index就是上面的16，也就是在常量池中的有效索引，当我们去看常量池的时候，我们就会找到index为16的值为String_info，里面存了/ef1s.png.

所以这行的意思就是把/ef1s.pn作为一个String存在常量池中，其有效索引为16。

第二行：2 invokestatic #18

invokestatic为虚拟机指令，作用是：调用类（static）方法，形式如下

invokestatic indexbyte1 indexbyte2

其中indexbyte1和indexbyte2必须是在常量池中的有效索引，而是指向的类型必须有Methodref标记，对类名,方法名和方法的描述符的引用。

所以当我们看常量池中索引为18的地方，我们就会得到以下信息：

Class Name : cp_info#1

Name Type : cp_info#19

1 和19都是常量池中的有效索引，值就是右边中的值，再往下跟踪我就不多说了，有兴趣的朋友可以去JAVA虚拟机规范。

这里我简单介绍一下parseImage(Ljava/lang/String;)[S 的意思。

这就是parseImage这个函数的运行，我们反过来看看parseImage的原型就明白了

short [] parseImage(String)

那么Ljava/lang/String;就是说需要传入一个String对象，而为什么前面要有一个L呢，这是JAVA虚拟机用来表示这是一个Object。如果是基本类型，这里就不需要有L了。然后返回为short的一维数组，也就是对应的[S。是不是很有意思，S对应着Short类型，而“[”对应一维数组，那有些朋友要问了，两维呢，那就“[[”，呵呵，是不是很有意思。

好了，调用了函数，返回的值要保存下来吧。那么就是第三行要做的事情了。

相关问答

Q1: 如何防止程序员反编译？

Java从诞生以来java源代码防破解，其基因就是开放精神，也正因此，其可以得到广泛爱好者的支持和奉献，最终很快发展壮大，以至于有今天之风光java源代码防破解！但随着java的应用领域越来越广，特别是一些功能要发布到终端用户手中（如Android开发的app），有时候，公司为java源代码防破解了商业技术的保密考虑，不希望这里面的一些核心代码能够被人破解（破解之后，甚至可以被简单改改就发布出去，说严重点，就可能会扰乱公司的正常软件的市场行为），这时候就要求这些java代码不能够被反编译。

这里要先说一下反编译的现象。因为java一直秉持着开放共享的理念，所以大家也都知道，java源代码防破解我们一般共享一个自己写的jar包时，同时会共享一个对应的source包。但这些依然与反编译没有什么关系，但java的共享理念，不只是建议我们这样做，而且它自己也在底层上“强迫”我们这么做！在java写的.java文件后，使用javac编译成class文件，在编译的过程，不像C/C++或C#那样编译时进行加密或混淆，它是直接对其进行符号化、标记化的编译处理，于是，也产生了一个逆向工程的问题：可以根据class文件反向解析成原来的java文件！这就是反编译的由来。

但很多时候，有些公司出于如上述的原因考虑时，真的不希望自己写的代码被别人反编译，尤其是那些收费的app或桌面软件（甚至还有一些j2ee的wen项目）！这时候，防止反编译就成了必然！但前面也说过了，因为开放理念的原因，class是可以被反编译的，那现在有这样的需求之后，有哪些方式可以做到防止反编译呢？经过研究java源代码并进行了一些技术实现（结果发现，以前都有人想到过，所以在对应章节的时候，我会贴出一些写得比较细的文章，而我就简单阐述一下，也算偷个懒吧），我总共整理出以下这几种方式：

代码混淆

这种方式的做法正如其名，是把代码打乱，并掺入一些随机或特殊的字符，让代码的可读性大大降低，“曲线救国”似的达到所谓的加密。其实，其本质就是打乱代码的顺序、将各类符号（如类名、方法名、属性名）进行随机或乱命名，使其无意义，让人读代码时很累，进而让人乍一看，以为这些代码是加过密的！

由其实现方式上可知，其实现原理只是扰乱正常的代码可读性，并不是真正的加密，如果一个人的耐心很好，依然可以理出整个程序在做什么，更何况，一个应用中，其核心代码才是人们想去了解的，所以大大缩小了代码阅读的范围！

当然，这种方式的存在，而且还比较流行，其原因在于，基本能防范一些技术人员进行反编译（比如说我，让我破解一个混淆的代码，我宁愿自己重写一个了）！而且其实现较为简单，对项目的代码又无开发上的侵入性。目前业界也有较多这类工具，有商用的，也有免费的，目前比较流行的免费的是：proguard（我现象临时用的就是这个）。

上面说了，这种方式其实并不是真正加密代码，其实代码还是能够被人反编译（有人可能说，使用proguard中的optimize选项，可以从字节流层面更改代码，甚至可以让JD这些反编译软件可以无法得到内容。说得有点道理，但有两个问题：1、使用optimize对JDK及环境要求较高，容易造成混淆后的代码无法正常运行java源代码防破解；2、这种方式其实还是混淆，JD反编译有点问题，可以有更强悍的工具，矛盾哲学在哪儿都是存在的^_^）。那如何能做到我的class代码无法被人反编译呢？那就需要我们下面的“加密class”！

加密class

在说加密class之前，我们要先了解一些java的基本概念，如：ClassLoader。做java的人已经或者以后会知道，java程序的运行，是类中的逻辑在JVM中运行，而类又是怎么加载到JVM中的呢（JVM内幕之类的，不在本文中阐述，所以点到为止）？答案是：ClassLoader。JVM在启动时是如何初始化整个环境的，有哪些ClassLoader及作用是什么，大家可以自己问度娘，也不在本文中讨论。

让我们从最常见的代码开始，揭开一下ClassLoader的一点点面纱！看下面的代码：

Java代码

public class Demo{

public static void main(String[] args){

System.out.println(“hello world!”);

}

}

上面这段代码，大家都认识。但我要问的是：如果我们使用javac对其进行编译，然后使用java使其运行（为什么不在Eclipse中使用Run as功能呢？因为Eclipse帮我们封闭，从而简化了太多东西，使我们忽略了太多的底层细节，只有从原始的操作上，我们才能看到本质），那么，它是怎么加载到JVM中的？答案是：通过AppClassLoader加载的（相关知识点可以参考：）！如果不相信的话，可以输出一下System.out.println(Thread.currentThrea().getContextLoader());看看。

那又有一个新的问题产生了：ClassLoader又是怎样加载class的呢？其实，AppClassLoader继承自java.lang.ClassLoader类，所以，基本操作都在这个类里面，让我们直接看下面这段核心代码吧：

看看这个方法中的逻辑，非常简单，先从内存中找，如果没有，则从父级或根先找，如果没找到，则再从自己的方法里面找！那findClass里面是什么样的呢？很不幸，这个方法是个抽象（abstract）的，也就是使用什么方式加载，由程序使用ClassLoader自己决定！这就给我们留下了巨大的“”！让我们看一下非常常见的一个ClassLoader的实现，那就是URLClassLoader（几乎所有的j2ee的web项目的容器使用的ClassLoader都是继承自它），让我们看一下它的findClass的实现：

这个方法里面的逻辑也很简单，从定义的ucp（就是各个jar包或class文件的具体路径）中读取指定的class文件的信息（如字节流之类），然后交给defineClass定义到JVM中，让我们继续看一下这个方法的核心部分：

看到这里，已经没有必要再往下面看了（再往下就是native方法了，这是一个重大伏笔哦），我们要做的手脚就在这里！

手脚怎么做呢？很简单，上面的代码逻辑告诉我们，ClassLoader只是拿到class文件中的内容byte[]，然后交给JVM初始化！于是我们的逻辑就简单了：只要在交给JVM时是正确的class文件就行了，在这之前是什么样子无所谓！所以，我们的加密的整个逻辑就是：

在编译代码时（如使用ant或maven），使用插件将代码进行加密（加密方式自己选），将class文件里面的内容读取成byte[]，然后进行加密后再写回到class文件（这时候class文件里面的内容不是标准的class，无法被反编译了）

在启动项目代码时，指定使用我们自定义的ClassLoader就行了，而自定义的部分，主要就是在这里做解密工作！

如此，搞定！以上的做法比较完整的阐述，可以仔细阅读一下这篇文章：文章中的介绍。

通过这个方法貌似可以解决代码反编译的问题了！错！这里有一个巨大的坑！因为我们自定义的ClassLoader是不能加密的，要不然JVM不认识，就全歇菜了！如果我来反编译，呵呵，我只要反编译一下这个自定义的ClassLoader，然后把里面解密后的内容写到指定的文件中保存下来，再把这个加了逻辑的自定义ClassLoader放回去运行，你猜结果会怎样？没错，你会想死！因为你好不容易想出来的加密算法，结果人家根本不需要破解，直接就绕过去了！

现在，让我们总结一下这个方法的优缺点：实现方式简单有效，同时对代码几乎没有侵入性，不影响正常开发与发布。缺点也很明显，就是很容易被人破解！

当然啦，关于缺点问题，你也可以这么干：先对所有代码进行混淆、再进行加密，保证：1、不容易找到我们自定义的那个ClassLoader；2、就算找到了，破解了，代码可读性还是很差，让你看得吐血！（有一篇文章，我觉得写得不错，大家可以看一看：）

嗯，我觉得这个方法很好，我自己也差点被这个想法感动了，但是，作为一个严谨的程序员，我真的不愿意留下一个隐患在这里！所以，我继续思索！

高级加密class

前面我们说过有个伏笔来着，还记得吧？没错，就是那个native！native定义的方法是什么方法？就是我们传说中的JNI调用！前面介绍过的有一篇文章中提到过，其实jvm的真实身份并不是java，而是c++写的jvm.dll（windows版本下），java与dll文件的调用就是通过JNI实现的！于是，我们就可以这样想：JNI可以调用第三方语言的类库，那么，我们可不可以把解密与装载使用第三方语言写（如C++，因为它们生成的库是不好反编译的），这样它可以把解密出来的class内容直接调jvm.dll的加载接口进行初始化成class，再返回给我们的ClassLoader？这样，我们自定义的ClassLoader只要使用JNI调用这个第三方语言写的组件，整个解密过程，都在黑盒中进行，别人就无从破解了！

嗯，这个方法真的很不错的！但也有两个小问题：1.使用第三方语言写，得会第三方语言，我说的会，是指很溜！2.对于不同的操作系统，甚至同一操作系统不同的版本，都可能要有差异化的代码生成对应环境下的组件（如window下是exe，linux是so等）！如果你不在乎这两个问题，我觉得，这个方式真的挺不错的。但对于我来说，我的信条是，越复杂的方式越容易出错！我个人比较崇尚简洁的美，所以，这个方法我不会轻易使用！

对了，如果大家觉得这个方法还算可行的话，可以推荐一个我无意中看到的东西给大家看看（我都没有用过的）：jinstall，

更改JVM

看到这个标题，我想你可能会震惊。是的，你没看错，做为一个程序员，是应该要具有怀疑一切、敢想敢做的信念。如果你有意留心的话，你会发现JVM版本在业界其实也有好几个版本的，如：Sun公司的、IBM的、Apache的、Google的……

所以，不要阻碍自己的想象力，现在没有这个能力，并不代表不可能。所以，我想到，如果我把jvm改了，在里面对加载的类进行解密，那不就可以了吗？我在设计构思过程中，突然发现：人老了就是容易糊涂！前面使用第三方语言实现解密的两个问题，正好也是更改JVM要面对的两个问题，而且还有一个更大的问题：这个JVM就得跟着这个项目到处走啊！

Q2: 如何有效防止Java程序源码被人偷窥？

;      Java程序的源代码很容易被别人偷看 只要有一个反编译器 任何人都可以分析别人的代码 本文讨论如何在不修改原有程序的情况下 通过加密技术保护源代码

一 为什么要加密?

对于传统的C或C++之类的语言来说 要在Web上保护源代码是很容易的 只要不发布它就可以 遗憾的是 Java程序的源代码很容易被别人偷看 只要有一个反编译器 任何人都可以分析别人的代码 Java的灵活性使得源代码很容易被窃取 但与此同时 它也使通过加密保护代码变得相对容易 我们唯一需要了解的就是Java的ClassLoader对象 当然 在加密过程中 有关Java Cryptography Extension(JCE)的知识也是必不可少的

有几种技术可以 模糊 Java类文件 使得反编译器处理类文件的效果大打折扣 然而 修改反编译器使之能够处理这些经过模糊处理的类文件并不是什么难事 所以不能简单地依赖模糊技术来保证源代码的安全

我们可以用流行的加密工具加密应用 比如PGP(Pretty Good Privacy)或GPG(GNU Privacy Guard) 这时 最终用户在运行应用之前必须先进行解密 但解密之后 最终用户就有了一份不加密的类文件 这和事先不进行加密没有什么差别

Java运行时装入字节码的机制隐含地意味着可以对字节码进行修改 JVM每次装入类文件时都需要一个称为ClassLoader的对象 这个对象负责把新的类装入正在运行的JVM JVM给ClassLoader一个包含了待装入类(比如java lang Object)名字的字符串 然后由ClassLoader负责找到类文件 装入原始数据 并把它转换成一个Class对象

我们可以通过定制ClassLoader 在类文件执行之前修改它 这种技术的应用非常广泛??在这里 它的用途是在类文件装入之时进行解密 因此可以看成是一种即时解密器 由于解密后的字节码文件永远不会保存到文件系统 所以窃密者很难得到解密后的代码

由于把原始字节码转换成Class对象的过程完全由系统负责 所以创建定制ClassLoader对象其实并不困难 只需先获得原始数据 接着就可以进行包含解密在内的任何转换

Java 在一定程度上简化了定制ClassLoader的构建 在Java 中 loadClass的缺省实现仍旧负责处理所有必需的步骤 但为了顾及各种定制的类装入过程 它还调用一个新的findClass方法

这为我们编写定制的ClassLoader提供了一条捷径 减少了麻烦 只需覆盖findClass 而不是覆盖loadClass 这种方法避免了重复所有装入器必需执行的公共步骤 因为这一切由loadClass负责

不过 本文的定制ClassLoader并不使用这种方法 原因很简单 如果由默认的ClassLoader先寻找经过加密的类文件 它可以找到;但由于类文件已经加密 所以它不会认可这个类文件 装入过程将失败 因此 我们必须自己实现loadClass 稍微增加了一些工作量

二 定制类装入器

每一个运行着的JVM已经拥有一个ClassLoader 这个默认的ClassLoader根据CLASSPATH环境变量的值 在本地文件系统中寻找合适的字节码文件

应用定制ClassLoader要求对这个过程有较为深入的认识 我们首先必须创建一个定制ClassLoader类的实例 然后显式地要求它装入另外一个类 这就强制JVM把该类以及所有它所需要的类关联到定制的ClassLoader Listing 显示了如何用定制ClassLoader装入类文件

【Listing 利用定制的ClassLoader装入类文件】

以下是引用片段

// 首先创建一个ClassLoader对象 ClassLoader myClassLoader = new myClassLoader(); // 利用定制ClassLoader对象装入类文件 // 并把它转换成Class对象 Class myClass = myClassLoader loadClass( mypackage MyClass ); // 最后 创建该类的一个实例 Object newInstance = myClass newInstance(); // 注意 MyClass所需要的所有其他类 都将通过 // 定制的ClassLoader自动装入

如前所述 定制ClassLoader只需先获取类文件的数据 然后把字节码传递给运行时系统 由后者完成余下的任务

ClassLoader有几个重要的方法 创建定制的ClassLoader时 我们只需覆盖其中的一个 即loadClass 提供获取原始类文件数据的代码 这个方法有两个参数 类的名字 以及一个表示JVM是否要求解析类名字的标记(即是否同时装入有依赖关系的类) 如果这个标记是true 我们只需在返回JVM之前调用resolveClass

【Listing ClassLoader loadClass()的一个简单实现】

以下是引用片段

public Class loadClass( String name boolean resolve ) throws ClassNotFoundException { try { // 我们要创建的Class对象 Class clasz = null; // 必需的步骤 如果类已经在系统缓冲之中 // 我们不必再次装入它 clasz = findLoadedClass( name ); if (clasz != null) return clasz; // 下面是定制部分 byte classData[] = /* 通过某种方法获取字节码数据 */; if (classData != null) { // 成功读取字节码数据 现在把它转换成一个Class对象 clasz = defineClass( name classData classData length ); } // 必需的步骤 如果上面没有成功 // 我们尝试用默认的ClassLoader装入它 if (clasz == null) clasz = findSystemClass( name ); // 必需的步骤 如有必要 则装入相关的类 if (resolve clasz != null) resolveClass( clasz ); // 把类返回给调用者 return clasz; } catch( IOException ie ) { throw new ClassNotFoundException( ie toString() ); } catch( GeneralSecurityException gse ) { throw new ClassNotFoundException( gse toString() ); } }

Listing 显示了一个简单的loadClass实现 代码中的大部分对所有ClassLoader对象来说都一样 但有一小部分(已通过注释标记)是特有的 在处理过程中 ClassLoader对象要用到其他几个辅助方法

findLoadedClass 用来进行检查 以便确认被请求的类当前还不存在 loadClass方法应该首先调用它

defineClass 获得原始类文件字节码数据之后 调用defineClass把它转换成一个Class对象 任何loadClass实现都必须调用这个方法

findSystemClass 提供默认ClassLoader的支持 如果用来寻找类的定制方法不能找到指定的类(或者有意地不用定制方法) 则可以调用该方法尝试默认的装入方式 这是很有用的 特别是从普通的JAR文件装入标准Java类时

resolveClass 当JVM想要装入的不仅包括指定的类 而且还包括该类引用的所有其他类时 它会把loadClass的resolve参数设置成true 这时 我们必须在返回刚刚装入的Class对象给调用者之前调用resolveClass

三 加密 解密

Java加密扩展即Java Cryptography Extension 简称JCE 它是Sun的加密服务软件 包含了加密和密匙生成功能 JCE是JCA(Java Cryptography Architecture)的一种扩展

JCE没有规定具体的加密算法 但提供了一个框架 加密算法的具体实现可以作为服务提供者加入 除了JCE框架之外 JCE软件包还包含了SunJCE服务提供者 其中包括许多有用的加密算法 比如DES(Data Encryption Standard)和Blowfish

为简单计 在本文中我们将用DES算法加密和解密字节码 下面是用JCE加密和解密数据必须遵循的基本步骤

步骤 生成一个安全密匙 在加密或解密任何数据之前需要有一个密匙 密匙是随同被加密的应用一起发布的一小段数据 Listing 显示了如何生成一个密匙 【Listing 生成一个密匙】

以下是引用片段

// DES算法要求有一个可信任的随机数源 SecureRandom sr = new SecureRandom(); // 为我们选择的DES算法生成一个KeyGenerator对象 KeyGenerator kg = KeyGenerator getInstance( DES ); kg init( sr ); // 生成密匙 SecretKey key = kg generateKey(); // 获取密匙数据 byte rawKeyData[] = key getEncoded(); /* 接下来就可以用密匙进行加密或解密 或者把它保存 为文件供以后使用 */ doSomething( rawKeyData );  步骤 加密数据 得到密匙之后 接下来就可以用它加密数据 除了解密的ClassLoader之外 一般还要有一个加密待发布应用的独立程序(见Listing ) 【Listing 用密匙加密原始数据】

以下是引用片段

// DES算法要求有一个可信任的随机数源 SecureRandom sr = new SecureRandom(); byte rawKeyData[] = /* 用某种方法获得密匙数据 */; // 从原始密匙数据创建DESKeySpec对象 DESKeySpec dks = new DESKeySpec( rawKeyData ); // 创建一个密匙工厂 然后用它把DESKeySpec转换成 // 一个SecretKey对象 SecretKeyFactory keyFactory = SecretKeyFactory getInstance( DES ); SecretKey key = keyFactory generateSecret( dks ); // Cipher对象实际完成加密操作 Cipher cipher = Cipher getInstance( DES ); // 用密匙初始化Cipher对象 cipher init( Cipher ENCRYPT_MODE key sr ); // 现在 获取数据并加密 byte data[] = /* 用某种方法获取数据 */ // 正式执行加密操作 byte encryptedData[] = cipher doFinal( data ); // 进一步处理加密后的数据 doSomething( encryptedData );  步骤 解密数据 运行经过加密的应用时 ClassLoader分析并解密类文件 操作步骤如Listing 所示 【Listing 用密匙解密数据】

// DES算法要求有一个可信任的随机数源 SecureRandom sr = new SecureRandom(); byte rawKeyData[] = /* 用某种方法获取原始密匙数据 */; // 从原始密匙数据创建一个DESKeySpec对象 DESKeySpec dks = new DESKeySpec( rawKeyData ); // 创建一个密匙工厂 然后用它把DESKeySpec对象转换成 // 一个SecretKey对象 SecretKeyFactory keyFactory = SecretKeyFactory getInstance( DES ); SecretKey key = keyFactory generateSecret( dks ); // Cipher对象实际完成解密操作 Cipher cipher = Cipher getInstance( DES ); // 用密匙初始化Cipher对象 cipher init( Cipher DECRYPT_MODE key sr ); // 现在 获取数据并解密 byte encryptedData[] = /* 获得经过加密的数据 */ // 正式执行解密操作 byte decryptedData[] = cipher doFinal( encryptedData ); // 进一步处理解密后的数据 doSomething( decryptedData );

四 应用实例

前面介绍了如何加密和解密数据 要部署一个经过加密的应用 步骤如下

步骤 创建应用 我们的例子包含一个App主类 两个辅助类(分别称为Foo和Bar) 这个应用没有什么实际功用 但只要我们能够加密这个应用 加密其他应用也就不在话下

步骤 生成一个安全密匙 在命令行 利用GenerateKey工具(参见GenerateKey java)把密匙写入一个文件 % java GenerateKey key data

步骤 加密应用 在命令行 利用EncryptClasses工具(参见EncryptClasses java)加密应用的类 % java EncryptClasses key data App class Foo class Bar class

该命令把每一个 class文件替换成它们各自的加密版本

步骤 运行经过加密的应用 用户通过一个DecryptStart程序运行经过加密的应用 DecryptStart程序如Listing 所示 【Listing DecryptStart java 启动被加密应用的程序】

以下是引用片段

import java io *; import java security *; import java lang reflect *; import javax crypto *; import javax crypto spec *; public class DecryptStart extends ClassLoader { // 这些对象在构造函数中设置 // 以后loadClass()方法将利用它们解密类 private SecretKey key; private Cipher cipher; // 构造函数 设置解密所需要的对象 public DecryptStart( SecretKey key ) throws GeneralSecurityException IOException { this key = key; String algorithm = DES ; SecureRandom sr = new SecureRandom(); System err println( [DecryptStart: creating cipher] ); cipher = Cipher getInstance( algorithm ); cipher init( Cipher DECRYPT_MODE key sr ); } // main过程 我们要在这里读入密匙 创建DecryptStart的 // 实例 它就是我们的定制ClassLoader // 设置好ClassLoader以后 我们用它装入应用实例 // 最后 我们通过Java Reflection API调用应用实例的main方法 static public void main( String args[] ) throws Exception { String keyFilename = args[ ]; String appName = args[ ]; // 这些是传递给应用本身的参数 String realArgs[] = new String[args length ]; System arraycopy( args realArgs args length ); // 读取密匙 System err println( [DecryptStart: reading key] ); byte rawKey[] = Util readFile( keyFilename ); DESKeySpec dks = new DESKeySpec( rawKey ); SecretKeyFactory keyFactory = SecretKeyFactory getInstance( DES ); SecretKey key = keyFactory generateSecret( dks ); // 创建解密的ClassLoader DecryptStart dr = new DecryptStart( key ); // 创建应用主类的一个实例 // 通过ClassLoader装入它 System err println( [DecryptStart: loading +appName+ ] ); Class clasz = dr loadClass( appName ); // 最后 通过Reflection API调用应用实例 // 的main()方法 // 获取一个对main()的引用 String proto[] = new String[ ]; Class mainArgs[] = { (new String[ ]) getClass() }; Method main = clasz getMethod( main mainArgs ); // 创建一个包含main()方法参数的数组 Object argsArray[] = { realArgs }; System err println( [DecryptStart: running +appName+ main()] ); // 调用main() main invoke( null argsArray ); } public Class loadClass( String name boolean resolve ) throws ClassNotFoundException { try { // 我们要创建的Class对象 Class clasz = null; // 必需的步骤 如果类已经在系统缓冲之中 // 我们不必再次装入它 clasz = findLoadedClass( name ); if (clasz != null) return clasz; // 下面是定制部分 try { // 读取经过加密的类文件 byte classData[] = Util readFile( name+ class ); if (classData != null) { // 解密 byte decryptedClassData[] = cipher doFinal( classData ); // 再把它转换成一个类 clasz = defineClass( name decryptedClassData decryptedClassData length ); System err println( [DecryptStart: decrypting class +name+ ] ); } } catch( FileNotFoundException fnfe ) // 必需的步骤 如果上面没有成功 // 我们尝试用默认的ClassLoader装入它 if (clasz == null) clasz = findSystemClass( name ); // 必需的步骤 如有必要 则装入相关的类 if (resolve clasz != null) resolveClass( clasz ); // 把类返回给调用者 return clasz; } catch( IOException ie ) { throw new ClassNotFoundException( ie toString() ); } catch( GeneralSecurityException gse ) { throw new ClassNotFoundException( gse toString() ); } } }  对于未经加密的应用 正常执行方式如下 % java App arg arg arg

对于经过加密的应用 则相应的运行方式为 % java DecryptStart key data App arg arg arg

DecryptStart有两个目的 一个DecryptStart的实例就是一个实施即时解密操作的定制ClassLoader;同时 DecryptStart还包含一个main过程 它创建解密器实例并用它装入和运行应用 示例应用App的代码包含在App java Foo java和Bar java内 Util java是一个文件I/O工具 本文示例多处用到了它 完整的代码请从本文最后下载

五 注意事项

我们看到 要在不修改源代码的情况下加密一个Java应用是很容易的 不过 世上没有完全安全的系统 本文的加密方式提供了一定程度的源代码保护 但对某些攻击来说它是脆弱的

虽然应用本身经过了加密 但启动程序DecryptStart没有加密 攻击者可以反编译启动程序并修改它 把解密后的类文件保存到磁盘 降低这种风险的办法之一是对启动程序进行高质量的模糊处理 或者 启动程序也可以采用直接编译成机器语言的代码 使得启动程序具有传统执行文件格式的安全性

另外还要记住的是 大多数JVM本身并不安全 狡猾的黑客可能会修改JVM 从ClassLoader之外获取解密后的代码并保存到磁盘 从而绕过本文的加密技术 Java没有为此提供真正有效的补救措施

lishixinzhi/Article/program/Java/hx/201311/25751

Q3: 【转】如何保护Java代码

以下从技术角度就常见的保护措施 和常用工具来看看如何有效保护java代码：1. 将java包装成exe 特点：将jar包装成可执行文件，便于使用，但对java程序没有任何保护。不要以为生成了exe就和普通可执行文件效果一样了。这些包装成exe的程序运行时都会将jar文件释放到临时目录，很容易获取。常用的工具有exe4j、jsmooth、NativeJ等等。jsmooth生成的exe运行时临时目录在exe所在目录中或是用户临时目录 中；exe4j生成的exe运行时临时目录在用户临时目录中；NativeJ生成的exe直接用winrar打开，然后用zip格式修复成一个jar文件，就得到了原文件。如果只是为了使用和发布方便，不需要保护java代码，使用这些工具是很好的选择。2. java混淆器特点：使用一种或多种处理方式将class文件、java源代码进行混淆处理后生成新的class，使混淆后的代码不易被反编译，而反编译后的代码难以阅 读和理解。这类混淆器工具很多，而且也很有成效。缺点：虽然混淆的代码反编译后不易读懂，但对于有经验的人或是多花些时间，还是能找到或计算出你代码中隐藏的敏感内容，而且在很多应用中不是全部代码都能混淆的，往往一些关键的库、类名、方法名、变量名等因使用要求的限制反而还不能混淆。3. 隔离java程序到服务端特点：把java程序放到服务端，让用户不能访问到class文件和相关配套文件，客户端只通过接口访问。这种方式在客户/服务模式的应用中能较好地保护java代码。缺点是：必须是客户/服务模式，这种特点限制了此种方式的使用范围；客户端因为逻辑的暴露始终是较为薄弱的环节，所以访问接口时一般都需要安全性认证。4. java加密保护特点：自定义ClassLoader，将class文件和相关文件加密，运行时由此ClassLoader解密相关文件并装载类，要起到保护作用必须自定 义本地代码执行器将自定义ClassLoader和加密解密的相关类和配套文件也保护起来。此种方式能很有效地保护java代码。缺点：可以通过替换JRE包中与类装载相关的java类或虚拟机动态库截获java字节码。 jar2exe属于这类工具。5. 提前编译技术(AOT) 特点：将java代码静态编译成本地机器码，脱离通用JRE。此种方式能够非常有效地保护java代码，且程序启动比通用JVM快一点。具有代表性的是GNU的gcj，可以做到对java代码完全提前编译，但gcj存在诸多局限性，如：对JRE 5不能完整支持、不支持JRE 6及以后的版本。由于java平台的复杂性，做到能及时支持最新java版本和JRE的完全提前编译是非常困难的，所以这类工具往往采取灵活方式，该用即时编译的地方还是 要用，成为提前编译和即时编译的混合体。缺点：由于与通用JRE的差异和java运用中的复杂性，并非java程序中的所有jar都能得到完全的保护；只能使用此种工具提供的一个运行环境，如果工具更新滞后或你需要特定版本的JRE，有可能得不到此种工具的支持。 Excelsior JET属于这类工具。6. 使用jni方式保护特点：将敏感的方法和数据通过jni方式处理。此种方式和“隔离java程序到服务端”有些类似，可以看作把需要保护的代码和数据“隔离”到动态库中，不同的是可以在单机程序中运用。缺点和上述“隔离java程序到服务端”类似。7. 不脱离JRE的综合方式保护特点：非提前编译，不脱离JRE，采用多种软保护方式，从多方面防止java程序被窃取。此种方式由于采取了多种保护措施，比如自定义执行器和装载器、加密、JNI、安全性检测、生成可执行文件等等，使保护力度大大增强，同样能够非常有效地保护java代码。缺点：由于jar文件存在方式的改变和java运用中的复杂性，并非java程序中的所有jar都能得到完全的保护；很有可能并不支持所有的JRE版本。 JXMaker属于此类工具。8. 用加密锁硬件保护特点：使用与硬件相关的专用程序将java虚拟机启动程序加壳，将虚拟机配套文件和java程序加密，启动的是加壳程序，由加壳程序建立一个与硬件相关的 受保护的运行环境，为了加强安全性可以和加密锁内植入的程序互动。此种方式与以上“不脱离JRE的综合方式保护”相似，只是使用了专用硬件设备，也能很好地保护java代码。缺点：有人认为加密锁用户使用上不太方便，且每个安装需要附带一个。从以上描述中我们可以看出：1. 各种保护方式都有其优缺点，应根据实际选用2. 要更好地保护java代码应该使用综合的保护措施3. 单机环境中要真正有效保护java代码，必须要有本地代码程序配合当然，安全都是相对的，一方面看你的保护措施和使用的工具能达到的程度，一方面看黑客的意愿和能力，不能只从技术上保护知识产权。总之，在java 代码保护方面可以采取各种可能的方式，不可拘泥于那些条条框框。

Q4: 如何有效的防止Java程序被反编译和破解

由于Java字节码的抽象级别较高，因此它们较容易被反编译。下面介绍了几种常用的方法，用于保护Java字节码不被反编译。通常，这些方法不能够绝对防止程序被反编译，而是加大反编译的难度而已，因为这些方法都有自己的使用环境和弱点。

1.隔离Java程序

最简单的方法就是让用户不能够访问到Java Class程序，这种方法是最根本的方法，具体实现有多种方式。例如，开发人员可以将关键的Java Class放在服务器端，客户端通过访问服务器的相关接口来获得服务，而不是直接访问Class文件。这样黑客就没有办法反编译Class文件。目前，通过接口提供服务的标准和协议也越来越多，例如 HTTP、Web Service、RPC等。但是有很多应用都不适合这种保护方式，例如对于单机运行的程序就无法隔离Java程序。

2.对Class文件进行加密

为了防止Class文件被直接反编译，许多开发人员将一些关键的Class文件进行加密，例如对注册码、序列号管理相关的类等。在使用这些被加密的类之前，程序首先需要对这些类进行解密，而后再将这些类装载到JVM当中。这些类的解密可以由硬件完成，也可以使用软件完成。

在实现时，开发人员往往通过自定义ClassLoader类来完成加密类的装载(注意由于安全性的原因，Applet不能够支持自定义的ClassLoader)。自定义的ClassLoader首先找到加密的类，而后进行解密，最后将解密后的类装载到JVM当中。在这种保护方式中，自定义的ClassLoader是非常关键的类。由于它本身不是被加密的，因此它可能成为黑客最先攻击的目标。如果相关的解密密钥和算法被攻克，那么被加密的类也很容易被解密。

3.转换成本地代码

将程序转换成本地代码也是一种防止反编译的有效方法。因为本地代码往往难以被反编译。开发人员可以选择将整个应用程序转换成本地代码，也可以选择关键模块转换。如果仅仅转换关键部分模块，Java程序在使用这些模块时，需要使用JNI技术进行调用。当然，在使用这种技术保护Java程序的同时，也牺牲了Java的跨平台特性。对于不同的平台，我们需要维护不同版本的本地代码，这将加重软件支持和维护的工作。不过对于一些关键的模块，有时这种方案往往是必要的。为了保证这些本地代码不被修改和替代，通常需要对这些代码进行数字签名。在使用这些本地代码之前，往往需要对这些本地代码进行认证，确保这些代码没有被黑客更改。如果签名检查通过，则调用相关JNI方法。

4.代码混淆

代码混淆是对Class文件进行重新组织和处理，使得处理后的代码与处理前代码完成相同的功能(语义)。但是混淆后的代码很难被反编译，即反编译后得出的代码是非常难懂、晦涩的，因此反编译人员很难得出程序的真正语义。从理论上来说，黑客如果有足够的时间，被混淆的代码仍然可能被破解，甚至目前有些人正在研制反混淆的工具。但是从实际情况来看，由于混淆技术的多元化发展，混淆理论的成熟，经过混淆的Java代码还是能够很好地防止反编译。下面我们会详细介绍混淆技术，因为混淆是一种保护Java程序的重要技术。

Q5: java程序会被轻易的破解源代码么？

请搜索反编译,jad decompile，可以安装在myeclipse等java开发工具中，可以直接打开.class文件查看源代码，所以答案是可以破解。

java源代码防破解的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java暴力破解代码、java源代码防破解的信息别忘了在本站进行查找喔。