java混淆反编译

Ⅰ 如何防止代码被反编译

由于apk是android虚拟机加载的，它有一定的规范，加密apk后Dalvik无法识别apk了。完全避免是不可能的，总有人能够破解你的代码。但是有几种方式来提高被反编译取代码的难度。
1 关键代码使用jni调用本地代码，用c或者c++编写，因此相对比较难于反编译

2 混淆java代码。混淆是不改变代码逻辑的情况下，增加无用代码，或者重命名，使反编译后的源代码难于看懂。 网上开源的java代码混淆工具较多，一般是用ant的方式来编译的。

1 . 在工程文件project.properties中加入下proguard.config=proguard.cfg ， 如下所示：
target=android-8
proguard.config=proguard.cfg
Eclipse会通过此配置在工程目录生成proguard.cfg文件

2 . 生成keystore (如已有可直接利用)
按照下面的命令行 在D:\Program Files\Java\jdk1.6.0_07\bin>目录下，输入keytool -genkey -alias android.keystore -keyalg RSA -validity 100000 -keystore android.keystore
参数意义：-validity主要是证书的有效期，写100000天；空格，退格键 都算密码。
命令执行后会在D:\Program Files\Java\jdk1.6.0_07\bin>目录下生成 android.keystore文件。

3. 在Eclipce的操作
File -> Export -> Export Android Application -> Select project -> Using the existing keystore , and input password -> select the destination APK file

经过混淆后的源代码，原先的类名和方法名会被类似a,b,c。。。的字符所替换，混淆的原理其实也就是类名和方法名的映射。
但4大组件并没有混淆（所有在清单文件定义的组件不能被混淆），因为系统需要通过清单文件来查找和运行应用程序。

proguard.cfg 文件代码解读
-optimizationpasses 5 ->设置混淆的压缩比率 0 ~ 7
-dontusemixedcaseclassnames -> Aa aA
- ->如果应用程序引入的有jar包,并且想混淆jar包里面的class
-dontpreverify
-verbose ->混淆后生产映射文件 map 类名->转化后类名的映射

-optimizations !code/simplification/arithmetic,!field/*,!class/merging/* ->混淆采用的算法.

-keep public class * extends android.app.Activity ->所有activity的子类不要去混淆
-keep public class * extends android.app.Application
-keep public class * extends android.app.Service
-keep public class * extends android.content.BroadcastReceiver
-keep public class * extends android.content.ContentProvider
-keep public class * extends android.app.backup.BackupAgentHelper
-keep public class * extends android.preference.Preference
-keep public class com.android.vending.licensing.ILicensingService

-keepclasseswithmembernames class * {
native <methods>; -> 所有native的方法不能去混淆.
}

-keepclasseswithmembers class * {
public <init>(android.content.Context, android.util.AttributeSet);
-->某些构造方法不能去混淆
}

-keepclasseswithmembers class * {
public <init>(android.content.Context, android.util.AttributeSet, int);
}

-keepclassmembers class * extends android.app.Activity {
public void *(android.view.View);
}

-keepclassmembers enum * { -> 枚举类不能去混淆.
public static **[] values();
public static ** valueOf(java.lang.String);
}

-keep class * implements android.os.Parcelable { -> aidl文件不能去混淆.
public static final android.os.Parcelable$Creator *;
}

Ⅱ 如何防止class被反编译，の颐堑闹恫

可以使用代码混淆是对Class文件进行重新组织和处理，使得处理后的代码与处理前代码完成相同的功能(语义)。但是混淆后的代码很难被反编译，即反编译后得出的代码是非常难懂、晦涩的，因此反编译人员很难得出程序的真正语义。
从理论上来说，如果有足够的时间，被混淆的代码仍然可能被破解，甚至目前有些人正在研制反混淆的工具。但是从实际情况来看，由于混淆技术的多元化发展，混淆理论的成熟，经过混淆的Java代码还是能够很好地防止反编译。
app开发完后，最好做一下扫描和加固，应用扫描可以通过静态代码分析、动态数据跟踪，定位出风险代码，同时监控敏感数据的异常行为。
加固可以在一定程度上保护自己核心代码算法,提高破解/盗版/二次打包的难度，缓解代码注入/动态调试/内存注入攻击等。
目前市面上有很多第三方加固的平台， 如果新应用发布前需要扫描或者加固的话，可以先试试免费的，例如腾讯御安全，建议自己先去扫描测试下。

Ⅲ java的class文件，经过反编译以后获得的源代码是L(小写)，1，i(大写)，o(大写和小写),0的组合，是怎么回事

你看到的已经是源码了，没有办法看到开发时候写的代码，因为通过加密混淆软件，已经把原来写的代码中的变量、类名、方法都改成了混乱的组合方式了，所以你看到的都是很混乱的东西，你其实可以自己做一次对自己Java代码的混淆测试，看看源代码，再看看混淆后的，你就知道了，根本还原不了

Ⅳ javacompile混淆器怎么混淆后的class文件还是可以被反编译出来呢求高手指点....

混淆的作用并不是使class文件不能被反编译
混淆的作用是使反编译的代码更难让人阅读，比如一些计算金钱的敏感逻辑里有如下的代码(新金额=旧金额*某个倍率)：
double newMoney=oldMoney*rate;
如果这样的代码直接编译成class文件，别人反编译这个class文件就能很清楚的看到金钱的计算关系，混淆后代码可能就变成这样的了：
double a=b*c;
这样的代码别人即使反编译了，也是很难看懂其中的逻辑关系的

Ⅳ Java混淆编译器

最近试用了几个Java混淆器(Java Obfuscator) 感觉没有一个完全另人满意的 于是想干脆自己写一个得了 翻了几页Java虚拟机规范之后突发奇想 别的混淆器都是在编译好的byte code上做文章 能不能从源码直接编译成经过混淆的class文件呢？就这样花了一个多星期的时间写了一个Java混淆编译器(Java Obfuscator Compiler) Q: 什么是混淆器？ A: 由于Java程序运行时是动态连接的 因此编译成的目标文件中包含有符号表 使得Java程序很容易被反编译 混淆器可以打乱class文件中的符号信息 使反向工程变得非常困难 Q: 现有的混淆器有什么问题？ A: 现有的混淆器都是对编译好的class文件进行混淆 这样就需要编译和混淆两个步骤 并不是所有的符号都需要混淆 如果你开发的是一个类库 或者某些类需要动态装载 那些公共API就必须保留符号不变 这样别人才能使用你的类库 现有的混淆器提供了GUI或脚本的方式来对那些需要保留的符号名称进行配置 如果程序较大时配置工作变得很复杂 而程序一旦修改配置工作又要重新进行 某些混淆器能够调整字节码的顺序 使反编译更加困难 但我经历过混淆之后的程序运行出错的情况 Q: Java混淆编译器是如何工作的？ A: Java混淆编译器是在Sun JDK中提供的Java编译器(javac)的基础上完成的 修改了代码生成过程 对编译器生成的中间代码进行混淆 最后再生成class文件 这样编译和混淆只需要一个步骤就可以完成 另外可以在源程序中插入符号保留指令来控制哪些符号需要保留 不需要单独的配置 Q: 如何安装和运行JOC？ A: 下载joc jar () 运行java jar joc jar就可以启动Java混淆编译器 joc的命令行参数和javac完全相同 但增加了一个新的参数 Xobfuscate 它的用法如下 Xobfuscate:<level>其中<level>指定混淆级别 可以是以下几种级别 Xobfuscate:none不进行混淆 Xobfuscate:private 对所有private访问级别的元素进行混淆 Xobfuscate:package 对所有private或package private元素进行混淆 Xobfuscate:protected 对所有private package private protected元素进行混淆 Xobfuscate:public对所有的元素都进行混淆 Xobfuscate:all 相当于 Xobfuscate:public如果使用 Xobfuscate不带级别参数 则相当于 Xobfuscate:package Q: 如何使用符号保留指令？ A: 除了在命令行用 Xobfuscate参数控制符号混淆级别外 还可以在源代码中使用符号保留指令来控制那些符号需要保留 符号保留指令是一个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() {} }如果没有@preserve指令 则根据混淆级别及成员的访问级别来确定符号是否保留 对于类的符号保留指令可以附带一个保?留级别参数 来控制类成员的符号保留 包括 @preserve仅对类名进行保留 类成员的保留根据 Xobfuscate命令行参数决定 @preserve public 保留所有public成员 @preserve protected保留所有public和protected成员 @preserve package保留所有public protected package private成员 @preserve private保留所有成员 @preserve all相当于@preserve private Q: JOC有哪些限制？ A: 不支持分别编译 必须对所有的源文件进行混淆编译 最后给出一个JOC混淆的效果 源文件 import java awt event *;import javax swing *;public class AboutBox extends JDialog{ public AboutBox() { initform(); } JPanel panel = new JPanel(); JButton button = new JButton(); JLabel jLabel = new JLabel(); JTextArea jTextArea = new JTextArea(); /*** NOTE: The following code is required by the form designer * It can be modified using the form editor Do not* modify it using the code editor */ private void initform() { this setDefaultCloseOperation( WindowConstants DISPOSE_ON_CLOSE ); this getContentPane() setLayout( new java awt CardLayout()); this setModal( true ); this setResizable( false ); this setTitle( About ); panel setLayout( null ); button setText( OK ); button setBounds( ); panel add( button ); jLabel setText( File System Viewer for Swing ); jLabel setVerticalAlignment( SwingConstants TOP ); jLabel setBounds( ); panel add( jLabel ); jTextArea setFont( new java awt Font( Dialog )); jTextArea setLineWrap( true ); jTextArea setOpaque( false ); jTextArea setText( This puter program is protected by right law ); jTextArea setWrapstyleWord( true ); jTextArea setBounds( ); panel add( jTextArea ); this getContentPane() add( panel Card ); this setSize( ); button addActionListener( new java awt event ActionListener(){ public void actionPerformed( java awt event ActionEvent ev ){ ?button _actionPerformed( ev ); }}); } private void button _actionPerformed(ActionEvent ev) { this dispose(); }}经Javac编译后用JAD反编译的结果 import java awt *;import java awt event ActionEvent;import java awt event ActionListener;import javax swing *;import javax swing text JTextComponent;public class AboutBox extends JDialog{ JPanel panel ; JButton button ; JLabel jLabel ; JTextArea jTextArea ; public AboutBox() { panel = new JPanel(); button = new JButton(); jLabel = new JLabel(); jTextArea = new JTextArea(); initform(); } private void initform() { setDefaultCloseOperation( ); getContentPane() setLayout(new CardLayout()); setModal(true); setResizable(false); setTitle( About ); panel setLayout(null); button setText( OK ); button setBounds( ); panel add(button ); jLabel setText( File System Viewer for Swing ); jLabel setVerticalAlignment( ); jLabel setBounds( ); panel add(jLabel ); jTextArea setFont(new Font( Dialog )); jTextArea setLineWrap(true); jTextArea setOpaque(false); jTextArea setText( This puter program is protected by right law ); jTextArea setWrapstyleWord(true); jTextArea setBounds( ); panel add(jTextArea ); getContentPane() add(panel Card ); setSize( ); button addActionListener(new ActionListener() { public void actionPerformed(ActionEvent actionevent) { button _actionPerformed(actio lishixin/Article/program/Java/JSP/201311/19213

Ⅵ 如何混淆Java编译后的类或jar，或将jar编译成exe，使人无法反编译获得源代码

混淆就可以了
我一直在用proguard4.5.1做Java项目的混淆

Ⅶ 如何防止程序员反编译

Java从诞生以来，其基因就是开放精神，也正因此，其可以得到广泛爱好者的支持和奉献，最终很快发展壮大，以至于有今天之风光！但随着java的应用领域越来越广，特别是一些功能要发布到终端用户手中（如Android开发的app），有时候，公司为了商业技术的保密考虑，不希望这里面的一些核心代码能够被人破解（破解之后，甚至可以被简单改改就发布出去，说严重点，就可能会扰乱公司的正常软件的市场行为），这时候就要求这些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及环境要求较高，容易造成混淆后的代码无法正常运行；2、这种方式其实还是混淆，JD反编译有点问题，可以有更强悍的工具，矛盾哲学在哪儿都是存在的^_^）。那如何能做到我的class代码无法被人反编译呢？那就需要我们下面的“加密class”！

加密class

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

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

Java代码

• publicclassDemo{

• publicstaticvoidmain(String[]args){

• System.out.println(“helloworld!”);

• }

• }

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

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





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

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

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

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

如此，搞定！以上的做法比较完整的阐述，可以仔细阅读一下这篇文章：https://www.ddtsoft.com/#developerworks/cn/java/l-secureclass/文章中的介绍。

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

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

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

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

高级加密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就得跟着这个项目到处走啊！

Ⅷ 我想反编译 一个APK程序，但是那个APK程序的代码被混淆了，导致APK反编译失败，请问这个问题怎么解决

你的这个问题想想就知道不能解决的，为什么？总所周知Java的代码容易被反编译，非常简单，让我自己写反编译工具我也能写，如果市场上的软件都这样直接发布出去，那开发者的劳动成果怎么保证？谁还愿意开发？抄袭人家的就是了。正因为如此才诞生了代码混淆，代码混淆的作用就是防止apk被反编译的。
我们假定混淆代码也没起作用，后面的灾难性局面你自己去想象吧。。。