混淆代码_代码混淆 - CSDN
精华内容
参与话题
  • 教你5步搞定代码混淆

    万次阅读 2017-04-20 11:32:22
    代码混淆是上线前必不可少的一部分操作,作为一个高逼格程序员,怎么让自己的混淆看起来更专业,更高逼格呢!简单来说,有条理,让人一目了然,当然这是给你同伴看滴,对于那些想要反编译的朋友来说还是越难懂越好咯...

    代码混淆是上线前必不可少的一部分操作,作为一个高逼格程序员,怎么让自己的混淆看起来更专业,更高逼格呢!简单来说,有条理,让人一目了然,当然这是给你同伴看滴,对于那些想要反编译的朋友来说还是越难懂越好咯。不多说,看文档;

    分为5部分:
    =================== 定制化区域=================
    1. 实体类区域
    项目中的实体类,最好放在一个包下,如果没有也没关系,一个个添加下就可以了!比如我的实体类大多数放在entity包下面,所以就这样写:

    -keep class com.qmovies.media.TV.entity.** { *; }
    1. 第三方包区域
      项目中使用第三方包是很难避免的!一般所使用的第三方包官方都会有提供,如果没有,那就Google或者百度,实在找不到,就自己写吧:

      贴一下我常用的包,这些包的混淆配置在下面都有配置。
      compile ‘com.google.code.gson:gson:2.8.0’
      compile ‘com.android.support:appcompat-v7:25.1.1’
      compile ‘com.android.support:support-v4:25.1.1’
      compile ‘com.android.support:design:25.1.1’
      compile ‘com.flyco.tablayout:FlycoTabLayout_Lib:2.0.0@aar’
      compile ‘com.miguelcatalan:materialsearchview:1.4.0’
      compile ‘com.jakewharton:butterknife:8.4.0’
      compile ‘io.reactivex:rxandroid:1.1.0’
      compile ‘io.reactivex:rxjava:1.1.0’
      compile ‘com.artemzin.rxjava:proguard-rules:1.2.9.0’
      compile ‘com.github.bumptech.glide:glide:3.7.0’
      compile ‘com.trello:rxlifecycle-components:0.6.1’
      compile ‘com.facebook.stetho:stetho:1.3.1’
      compile ‘com.facebook.stetho:stetho-okhttp3:1.3.1’
      compile ‘com.google.code.gson:gson:2.8.0’
      compile ‘com.squareup.retrofit2:retrofit:2.0.0-beta4’
      compile ‘com.squareup.retrofit2:adapter-rxjava:2.0.0-beta4’
      compile ‘com.squareup.retrofit2:converter-gson:2.0.0-beta4’
      compile ‘com.squareup.okhttp3:okhttp:3.2.0’
      compile ‘com.squareup.okhttp3:logging-interceptor:3.2.0’
      compile ‘com.android.support:cardview-v7:25.1.1’
      compile ‘com.google.android.exoplayer:exoplayer:r2.2.0’
      compile ‘org.jbundle.util.osgi.wrapped:org.jbundle.util.osgi.wrapped.org.apache.http.client:4.1.2’
      testCompile ‘junit:junit:4.12’
      apt ‘com.jakewharton:butterknife-compiler:8.4.0’
      compile ‘com.umeng.analytics:analytics:latest.integration


    如果你实在没有找到,该怎么写呢?
    第一种:按部就班的照抄,抄格式。
    第二种:我就这个包的所有文件都不提示,不混淆了。能拿我怎样?比如下面这个。
    我的导入包名为: compile 'com.flyco.tablayout:FlycoTabLayout_Lib:2.0.0@aar'
    混淆配置可以写成:
    ```
    #flyco
    -dontwarn com.flyco.tablayout.**
    -keep class com.flyco.tablaout.**{ *;}
    ```
    

    1. 与js互调区域
      工程中没用到,可不写。
    2. 反射相关区域
      工程中没用到,可不写。

    ==================基本不用动区域================
    1. 基本指令区域
    2. 默认保留区
    3. webView
    这个区域基本通用,可以照抄。

    在proguard-rules.pro中添加如下文件:

    #-------------------------------------------定制化区域----------------------------------------------
    #---------------------------------1.实体类---------------------------------
    
    -keep class com.qmovies.media.TV.entity.** { *; }
    -keep class com.qmovies.media.TV.model.entity.** { *; }
    -keep class com.qmovies.media.TV.model.task.TasksManagerModel { *; }
    -keep class com.qmovies.media.TV.widght.banner.BannerEntity { *; }
    
    
    #-------------------------------------------------------------------------
    
    #---------------------------------2.第三方包-------------------------------
    ##---------------Begin: proguard configuration for Gson ----------
    -keep public class com.google.gson.**
    -keep public class com.google.gson.** {public private protected *;}
    
    -keepattributes Signature
    -keepattributes *Annotation*
    -keep public class com.project.mocha_patient.login.SignResponseData { private *; }
    
    ##---------------End: proguard configuration for Gson ----------
    #如果需要保存内部类,需要如下声明
    -keep class com.project.mocha_patient.login.FindForgotInfoActivity$ForgetResponse {*;}
    -keep class com.project.mocha_patient.account_setting.ChangePasswordActivity$ChangePasswordResponse {*;}
    
    #Glide
    -keep public class * implements com.bumptech.glide.module.GlideModule
    -keep public enum com.bumptech.glide.load.resource.bitmap.ImageHeaderParser$** {
      **[] $VALUES;
      public *;
    }
    #OkHttp
    -dontwarn com.squareup.okhttp3.**
    -keep class com.squareup.okhttp3.** { *;}
    -dontwarn okio.**
    #retrofit2
    -dontwarn retrofit2.**
    -keep class retrofit2.** { *; }
    -keepattributes Signature
    -keepattributes Exceptions
    #stetho
    -keep class com.facebook.stetho.** { *; }
    -dontwarn org.mozilla.javascript.**
    -dontwarn org.mozilla.classfile.**
    -keep class org.mozilla.javascript.** { *; }
    
    ##Butterknife
    -keep class butterknife.** { *; }
    -dontwarn butterknife.internal.**
    -keep class **$$ViewBinder { *; }
    
    -keepclasseswithmembernames class * {
        @butterknife.* <fields>;
    }
    
    -keepclasseswithmembernames class * {
        @butterknife.* <methods>;
    }
    #RxJava/RxAndroid
    -dontwarn sun.misc.**
    -keepclassmembers class rx.internal.util.unsafe.*ArrayQueue*Field* {
       long producerIndex;
       long consumerIndex;
    }
    -keepclassmembers class rx.internal.util.unsafe.BaseLinkedQueueProducerNodeRef {
        rx.internal.util.atomic.LinkedQueueNode producerNode;
    }
    -keepclassmembers class rx.internal.util.unsafe.BaseLinkedQueueConsumerNodeRef {
        rx.internal.util.atomic.LinkedQueueNode consumerNode;
    }
    
    #友盟统计
    -keepclassmembers class * {
       public <init> (org.json.JSONObject);
    }
    #友盟推送
    -dontwarn com.taobao.**
    -dontwarn anet.channel.**
    -dontwarn anetwork.channel.**
    -dontwarn org.android.**
    -dontwarn org.apache.thrift.**
    -dontwarn com.xiaomi.**
    -dontwarn com.huawei.**
    -dontwarn com.ta.**
    -keep class com.taobao.** {*;}
    -keep class org.android.** {*;}
    -keep class anet.channel.** {*;}
    -keep class com.umeng.** {*;}
    -keep class com.xiaomi.** {*;}
    -keep class com.huawei.** {*;}
    -keep class org.apache.thrift.** {*;}
    
    -keep class com.alibaba.sdk.android.**{*;}
    -keep class com.ut.**{*;}
    -keep class com.ta.**{*;}
    #flyco
    -dontwarn com.flyco.tablayout.**
    -keep class com.flyco.tablaout.**{ *;}
    
    #org.apache.http
    -dontwarn org.apache.http.**
    -keep class org.apache.http.**{ *;}
    
    #-------------------------------------------------------------------------
    
    #-------------------------------------------------------------------------
    
    #---------------------------------3.与js互相调用的类------------------------
    
    
    
    #-------------------------------------------------------------------------
    
    #---------------------------------4.反射相关的类和方法-----------------------
    
    
    # 下拉刷新
    -keep class in.srain.cube.** { *; }
    -keep interface in.srain.cube.** { *; }
    -dontwarn in.srain.cube.**
    # observablescrollview:tab fragment
    -keep class com.github.ksoichiro.** { *; }
    -keep interface com.github.ksoichiro.** { *; }
    -dontwarn com.github.ksoichiro.**
    
    #-------------------------------------------基本不用动区域--------------------------------------------
    #---------------------------------基本指令区----------------------------------
    -optimizationpasses 5
    -dontusemixedcaseclassnames
    -dontskipnonpubliclibraryclasses
    -dontskipnonpubliclibraryclassmembers
    -dontpreverify
    -verbose
    -printmapping proguardMapping.txt
    -optimizations !code/simplification/cast,!field/*,!class/merging/*
    -keepattributes *Annotation*,InnerClasses
    -keepattributes Signature
    -keepattributes SourceFile,LineNumberTable
    #----------------------------------------------------------------------------
    
    #---------------------------------默认保留区---------------------------------
    #保护注解
    -keepattributes *Annotation*
    -keep public class * extends android.app.Fragment
    -keep public class * extends android.app.Activity
    -keep public class * extends android.app.Appliction
    -keep public class * extends android.app.Service
    -keep public class * extends android.content.BroadcastReceiver
    -keep public class * extends android.preference.Preference
    -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 * extends android.view.View
    -keep public class com.android.vending.licensing.ILicensingService
    -keep class android.support.** {*;}
    #保持 native 方法不被混淆
    -keepclasseswithmembernames class * {
        native <methods>;
    }
    #保持自定义控件类不被混淆
    -keepclassmembers class * extends android.app.Activity{
        public void *(android.view.View);
    }
    #保持枚举 enum 类不被混淆
    -keepclassmembers enum * {
        public static **[] values();
        public static ** valueOf(java.lang.String);
    }
    -keep public class * extends android.view.View{
        *** get*();
        void set*(***);
        public <init>(android.content.Context);
        public <init>(android.content.Context, android.util.AttributeSet);
        public <init>(android.content.Context, android.util.AttributeSet, int);
    }
    -keepclasseswithmembers class * {
        public <init>(android.content.Context, android.util.AttributeSet);
        public <init>(android.content.Context, android.util.AttributeSet, int);
    }
    
    #保持 Parcelable 不被混淆
    -keep class * implements android.os.Parcelable {
      public static final android.os.Parcelable$Creator *;
    }
    #保持 Serializable 不被混淆
    -keepclassmembers class * implements java.io.Serializable {
        static final long serialVersionUID;
        private static final java.io.ObjectStreamField[] serialPersistentFields;
        private void writeObject(java.io.ObjectOutputStream);
        private void readObject(java.io.ObjectInputStream);
        java.lang.Object writeReplace();
        java.lang.Object readResolve();
    }
    #不混淆资源类
    -keep class **.R$* {
     *;
    }
    -keepclassmembers class * {
        void *(**On*Event);
    }
    #----------------------------------------------------------------------------
    
    #---------------------------------webview------------------------------------
    -keepclassmembers class fqcn.of.javascript.interface.for.webview {
       public *;
    }
    -keepclassmembers class * extends android.webkit.webViewClient {
        public void *(android.webkit.WebView, java.lang.String, android.graphics.Bitmap);
        public boolean *(android.webkit.WebView, java.lang.String);
    }
    -keepclassmembers class * extends android.webkit.webViewClient {
        public void *(android.webkit.webView, jav.lang.String);
    }
    #----------------------------------------------------------------------------
    #---------------------------------------------------------------------------------------------------

    添加后将minifyEnabled设置为true,打包即可。

    最后来一句,学习在于积累,文章认真写好每一篇,写着写着就发现自己的**提高了!有什么问题可以留言,看到及时回复。

    文章参考链接:5步教你搞定Android混淆

    展开全文
  • 代码混淆详解

    千次阅读 2016-04-13 09:40:06
    什么是代码混淆保留内部类不被混淆-keepnames class com.AnywayAds.Mini$* { public ; public ;}或者-keep class com.brutegame.hongniang.EventMemberListActivity$EventMemberListFragment$Page* { *; }//...
    什么是代码混淆

    保留内部类不被混淆
    -keepnames class com.AnywayAds.Mini$* {
        public <fields>;
        public <methods>;
    }

    或者

    -keep class com.brutegame.hongniang.EventMemberListActivity$EventMemberListFragment$Page* { *; }//EventMemberListActivity中的EventMemberListFragment类中的Page类的方法和属性都不混淆

    Java 是一种跨平台的、解释型语言,Java 源代码编译成中间”字节码”存储于 class 文件中。由于跨平台的需要,Java 字节码中包括了很多源代码信息,如变量名、方法名,并且通过这些名称来访问变量和方法,这些符号带有许多语义信息,很容易被反编译成 Java 源代码。为了防止这种现象,我们可以使用 Java 混淆器对 Java 字节码进行混淆。

    混淆就是对发布出去的程序进行重新组织和处理,使得处理后的代码与处理前代码完成相同的功能,而混淆后的代码很难被反编译,即使反编译成功也很难得出程序的真正语义。被混淆过的程序代码,仍然遵照原来的档案格式和指令集,执行结果也与混淆前一样,只是混淆器将代码中的所有变量、函数、类的名称变为简短的英文字母代号,在缺乏相应的函数名和程序注释的况下,即使被反编译,也将难以阅读。同时混淆是不可逆的,在混淆的过程中一些不影响正常运行的信息将永久丢失,这些信息的丢失使程序变得更加难以理解。

    混淆器的作用不仅仅是保护代码,它也有精简编译后程序大小的作用。由于以上介绍的缩短变量和函数名以及丢失部分信息的原因, 编译后 jar 文件体积大约能减少25% ,这对当前费用较贵的无线网络传输是有一定意义的。

    混淆文件 proguard.cfg 参数详解

    [plain] view plain copy 在CODE上查看代码片派生到我的代码片
    -optimizationpasses 5                                                           # 指定代码的压缩级别  
    -dontusemixedcaseclassnames                                                     # 是否使用大小写混合  
    -dontskipnonpubliclibraryclasses                                                # 是否混淆第三方jar  
    -dontpreverify                                                                  # 混淆时是否做预校验  
    -verbose                                                                        # 混淆时是否记录日志  
    -optimizations !code/simplification/arithmetic,!field/*,!class/merging/*        # 混淆时所采用的算法  
      
    -keep public class * extends android.app.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 方法不被混淆  
        native <methods>;  
    }  
      
    -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 * {                                                      # 保持枚举 enum 类不被混淆  
        public static **[] values();  
        public static ** valueOf(java.lang.String);  
    }  
      
    -keep class * implements android.os.Parcelable {                                # 保持 Parcelable 不被混淆  
      public static final android.os.Parcelable$Creator *;  
    }  
      
    -keep class MyClass;                                                            # 保持自己定义的类不被混淆  


    代码混淆的方法

    根据 SDK 的版本不同有 2 中不同的代码混淆方式,以上的 proguard.cfg 参数详解中所涉及到的信息是在较低版本 SDK 下的混淆脚本,事实上在高版本的 SDK 下混淆的原理和参数也与低版本的相差无几,只是在不同 SDK 版本的环境下引入混淆脚本的方式有所不同。具体方法如下:

    低版本 SDK 下,项目中同时包含 proguard.cfg 和 project.properties 文件,则只需在 project.properties 文件末尾添加 proguard.config=proguard.cfg 再将项目 Export 即可。
    高版本 SDK 下,项目中同时包含 proguard-project.txt 和 project.properties 文件,这时需要在 proguard-project.txt 文件中进行如下信息的配置,然后再将项目 Export 即可。下面以真实的文件进行演示说明。
    复制代码
    # This file is automatically generated by Android Tools.
    # Do not modify this file -- YOUR CHANGES WILL BE ERASED!
    #
    # This file must be checked in Version Control Systems.
    #
    # To customize properties used by the Ant build system edit
    # "ant.properties", and override values to adapt the script to your
    # project structure.
    #
    # To enable ProGuard to shrink and obfuscate your code, uncomment this (available properties: sdk.dir, user.home):
    #proguard.config=${sdk.dir}/tools/proguard/proguard-android.txt:proguard-project.txt

    proguard.config=${sdk.dir}/tools/proguard/proguard-android.txt:proguard-project.txt

    # Project target.
    target=android-16
    复制代码
    以上的配置信息即是 project.properties 文件中内容,蓝色文字为我们在代码混淆过程中需要添加的配置信息,其中:sdk.dir 为你在当前机器上 SDK 的安装路径。如果想保留某个包下的文件不被混淆,可以在 proguard-project.txt文件中加入保留对应包名的语句即可。

    复制代码
    # To enable ProGuard in your project, edit project.properties
    # to define the proguard.config property as described in that file.
    #
    # Add project specific ProGuard rules here.
    # By default, the flags in this file are appended to flags specified
    # in ${sdk.dir}/tools/proguard/proguard-android.txt
    # You can edit the include path and order by changing the ProGuard
    # include property in project.properties.
    #
    # For more details, see
    #   http://developer.android.com/guide/developing/tools/proguard.html

    # Add any project specific keep options here:

    -dontwarn com.cnki.android.cnkireader.** 
    -keep class com.cnki.android.cnkireader.** { *; }

    # If your project uses WebView with JS, uncomment the following
    # and specify the fully qualified class name to the JavaScript interface
    # class:
    #-keepclassmembers class fqcn.of.javascript.interface.for.webview {
    #   public *;
    #}
    复制代码


    -optimizationpasses 5


    # 混淆时不会产生形形色色的类名 
    -dontusemixedcaseclassnames


    # 指定不去忽略非公共的库类
    -dontskipnonpubliclibraryclasses


    # 不预校验
    # -dontpreverify


    # 预校验
    -dontoptimize 




    # 这1句是屏蔽警告
    -ignorewarnings 
    -verbose


    # 优化
    -optimizations !code/simplification/arithmetic,!field/*,!class/merging/*


    # 这1句是导入第三方的类库,防止混淆时候读取包内容出错
    #-libraryjars libs/youjar.jar 


    # 去掉警告
    -dontwarn 
    -dontskipnonpubliclibraryclassmembers


    # 不进行混淆保持原样
    -keep public class * extends android.app.Activity
    -keep public class * extends android.app.Application
    -keep public class * extends android.app.Fragment 
    -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




    # 过滤R文件的混淆:
    -keep class **.R$* {*;}


    # 过滤第三方包的混淆:其中packagename为第三方包的包名
    # -keep class packagename.** {*;}
    -keep class com.hisilicon.android.hibdinfo.** {*;}
    -keep class com.huawei.iptv.stb.dlna.mymedia.dto.** {*;}
    -keep class com.huawei.iptv.stb.dlna.mymedia.facade.** {*;}
    -keep class com.huawei.mymediaprifacade.** {*;}
    -keep class com.hisilicon.android.mediaplayer.** {*;}
    -keep class com.nostra13.universalimageloader.** {*;}
    -keep class com.huawei.android.airsharing.** {*;}


    # 所有方法不进行混淆
    -keep public abstract interface com.huawei.android.airsharing.listener{
    public protected <methods>;
    }


    -keep public abstract interface com.huawei.android.airsharing.api{
    public protected <methods>;
    }


    # 对该方法不进行混淆
    # -keep public class com.asqw.android{
    # public void Start(java.lang.String); 
    # }


    # 保护指定的类和类的成员的名称,如果所有指定的类成员出席(在压缩步骤之后)
    #-keepclasseswithmembernames class * {
    #    native <methods>;
    #}


    # 保护指定的类和类的成员,但条件是所有指定的类和类成员是要存在
    #-keepclasseswithmembernames class * {
    #    public <init>(android.content.Context, android.util.AttributeSet);
    #}


    -keepclasseswithmembernames 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 {
      public static final android.os.Parcelable$Creator *;
    }


    #-libraryjars libs/android-support-v4.jar
    #-dontwarn android.support.v4.**{*;}


    # If your project uses WebView with JS, uncomment the following
    # and specify the fully qualified class name to the JavaScript interface
    # class:
    -keepclassmembers class fqcn.of.javascript.interface.for.webview {
       public *;
    }


    #不混淆第三方包中的指定内容
    -keep class android-support-v4.**{*;}
    -keep public class * extends android.support.v4.**
    -keep class android.view.**{*;}









    ProGuard是一个免费的java类文件压缩,优化,混淆器.它探测并删除没有使用的类,字段,方法和属性.它删除没有用的说明并使用字节码得到最大优化.它使用无意义的名字来重命名类,字段和方法.

    ProGuard的使用是为了:

    1.创建紧凑的代码文档是为了更快的网络传输,快速装载和更小的内存占用.
    2.创建的程序和程序库很难使用反向工程.
    3.所以它能删除来自源文件中的没有调用的代码
    4.充分利用java6的快速加载的优点来提前检测和返回java6中存在的类文件.

    参数:

    -include {filename} 从给定的文件中读取配置参数

    -basedirectory {directoryname} 指定基础目录为以后相对的档案名称

    -injars {class_path} 指定要处理的应用程序jar,war,ear和目录

    -outjars {class_path} 指定处理完后要输出的jar,war,ear和目录的名称

    -libraryjars {classpath} 指定要处理的应用程序jar,war,ear和目录所需要的程序库文件

    -dontskipnonpubliclibraryclasses 指定不去忽略非公共的库类。

    -dontskipnonpubliclibraryclassmembers 指定不去忽略包可见的库类的成员。

    保留选项
    -keep {Modifier} {class_specification} 保护指定的类文件和类的成员

    -keepclassmembers {modifier} {class_specification} 保护指定类的成员,如果此类受到保护他们会保护的更好

    -keepclasseswithmembers {class_specification} 保护指定的类和类的成员,但条件是所有指定的类和类成员是要存在。

    -keepnames {class_specification} 保护指定的类和类的成员的名称(如果他们不会压缩步骤中删除)

    -keepclassmembernames {class_specification} 保护指定的类的成员的名称(如果他们不会压缩步骤中删除)

    -keepclasseswithmembernames {class_specification} 保护指定的类和类的成员的名称,如果所有指定的类成员出席(在压缩步骤之后)

    -printseeds {filename} 列出类和类的成员-keep选项的清单,标准输出到给定的文件

    压缩
    -dontshrink 不压缩输入的类文件

    -printusage {filename}

    -whyareyoukeeping {class_specification}

    优化
    -dontoptimize 不优化输入的类文件

    -assumenosideeffects {class_specification} 优化时假设指定的方法,没有任何副作用

    -allowaccessmodification 优化时允许访问并修改有修饰符的类和类的成员

    混淆
    -dontobfuscate 不混淆输入的类文件

    -printmapping {filename}

    -applymapping {filename} 重用映射增加混淆

    -obfuscationdictionary {filename} 使用给定文件中的关键字作为要混淆方法的名称

    -overloadaggressively 混淆时应用侵入式重载

    -useuniqueclassmembernames 确定统一的混淆类的成员名称来增加混淆

    -flattenpackagehierarchy {package_name} 重新包装所有重命名的包并放在给定的单一包中

    -repackageclass {package_name} 重新包装所有重命名的类文件中放在给定的单一包中

    -dontusemixedcaseclassnames 混淆时不会产生形形色色的类名

    -keepattributes {attribute_name,...} 保护给定的可选属性,例如LineNumberTable, LocalVariableTable, SourceFile, Deprecated, Synthetic, Signature, and InnerClasses.

    -renamesourcefileattribute {string} 设置源文件中给定的字符串常量
    因为我们开发的是webwork+spring+hibernate的架构的项目,所有需要很详细的配置。(经过n次失败后总结)
    Example:
    -injars <project>.jar
    -outjars <project>_out.jar
    -libraryjars <java.home>/lib/rt.jar
    -libraryjars <project.home>/webroot/WEB-INF/lib/webwork.jar
    .......
    # 保留实现Action接口类中的公有的,友好的,私有的属性 和 公有的,友好的方法。其它的全部压缩,优化,混淆。
    # 因为配置文件中的类名是一个完整的类名,如果经过处理后就有可能找不到这个类。
    # 属性是jsp页面所需要的,如果经过处理jsp页面就无法得到action中的数据。
    -keep public class * implements com.opensymphony.xwork.Action{
    public protected private <fields>;
    public protected <methods>;
    }
    # 保留实现了Serializable接口类中的公有的,友好的,私有的成员(属性和方法)
    # 这个配置主要是对应实体类的配置。
    -keep public class * implements java.io.Serializable{
    public protected private *;
    }


    由于工作需要,这两天和同事在研究android下面的ProGuard工具的使用,通过查看android官网对该工具的介绍以及网络上其它相关资料,再加上自己的亲手实践,算是有了一个基本了解。下面将自己的理解和认识简要的做个笔记,有异议或者不解的,可以直接留言。

    什么是ProGuard工具?

    ProGuard是android提供的一个免费的工具,它能够移除工程中一些没用的代码,或者使用语义上隐晦的名称来重命名代码中的类、字段和函数等,达到压缩、优化和混淆代码的功能。具体来说,使用ProGuard工具,可以达到下面两个目的:

    删除了源文件中没有调用的那部分代码,最大化的精简了字节码文件,使得最终生成的apk文件更小。
    使用语义混淆的命名替换了代码中的类、字段和函数等,使得其他人无法反编译获取源代码,起到对代码的保护作用。
    我看网上有不少人根据ProGuard工具的作用,直接称呼其为“混淆代码工具”,本文也暂时用这个词简称。

    更多的理解,可以参考ProGuard工具的官方文档地址:http://developer.android.com/tools/help/proguard.html

    ProGuard工具的集成与使用环境

    其实,ProGuard工具是已经集成到我们android系统中的,所以不需要用户手动的去集成。但是有一点需要注意,仅在程序处于Release模式时ProGuard才有效,反之在Debug模式是不能通过ProGuard来混淆代码的。

    根据ProGuard的具体使用环境,我分在Eclipse工具和android源码两种编译环境浅谈ProGuard的使用方法。

    Eclipse环境中ProGuard的使用

    以我电脑的android4.0环境为例,当我们在Eclipse中新建一个项目,或者导入一个已存在项目(保证当前项目没有语法错误)后,在工程的根目录,会自动生成两个ProGuard的混淆文件:proguard-project.txt和project.properties(在老版本的ADT中,只会生成一个叫proguard.cfg的文件)。我们先看下文件project.properties :

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    # This file is automatically generated by Android Tools.
    # Do not modify this file -- YOUR CHANGES WILL BE ERASED!
    #
    # This file must be checked in Version Control Systems.
    #
    # To customize properties used by the Ant build system edit
    # "ant.properties", and override values to adapt the script to your
    # project structure.
    #
    # To enable ProGuard to shrink and obfuscate your code, uncomment this (available properties: sdk.dir, user.home):
    #proguard.config=${sdk.dir}/tools/proguard/proguard-android.txt:proguard-project.txt

    # Project target.
    target=android-16
    看后面一段注释:To enable ProGuard to shrink and obfuscate your code, uncomment this (available properties: sdk.dir, user.home) ,意指要让ProGuard 来压缩和混淆代码,把这句注释去掉即可!所以,我们只要把下面一句注释取消即可,如下所示:

    1
    2
    # To enable ProGuard to shrink and obfuscate your code, uncomment this (available properties: sdk.dir, user.home):
    proguard.config=${sdk.dir}/tools/proguard/proguard-android.txt:proguard-project.txt
    我们仔细的看下这部分代码:这个地方是通过设置proguard.config属性来指定混淆代码的配置文件为本机SDK目录下面的proguard-android.txt文件,以及制定混淆的个性化配置文件为当前工程(eclipse下)根目录下面的proguard-project.txt文件 ,而后面这个文件,恰是我们刚才看到的原本在根目录下自动生成的另外一个文件!

    其实打开了这个地方,我们就已经可以混淆代码了,不过这里要注意:不能试图通过运行eclipse中的Run as 和 Debug as 菜单来生成混淆代码,必须通过如下图所示的方法将apk导出才行,当然你可以选择“签名”或者“不签名”:

    图片说明文字

    这样一步操作后,算是代码混淆完成了。那么怎么才能检验我们真的混淆了代码了呢?首先,我们能够看到在工程的根目录新生产了一个文件夹proguard,里面有四个文件,其内容如下:

    dump.txt : 描述了apk中所有类 文件中内部的结构体。( Describes the internal structure of all the class files in the .apk file )
    mapping.txt : 列出了原始的类、方法和名称与混淆代码见得映射。( Lists the mapping between the original and obfuscated class, method, and field names. )
    seeds.txt : 列出了没有混淆的类和方法。( Lists the classes and members that are not obfuscated )
    usage.txt : 列出congapk中删除的代码。( Lists the code that was stripped from the .apk )
    同时使用反编译软件对新生成的apk反编译后会发现,里面的类名、方法和变量等,都变成了简单的a、b、c、d等毫无含义的字母,这样就达到了混淆的目的:
    图片说明文字

    但在实际使用过程中,我们会发现当前apk中的有些方法和类,是要供外部使用的,而此时混淆了名称,外部调用就会报错了,那么怎么解决这个问题?此时就要用到我们刚才提到的混淆的个性化配置文件proguard-project.txt,在其中去配置不需要混淆的类、方法和变量等。关于混淆文件的具体配置方法,请看下面的最后一个标题会有详述。

    Android源码环境中ProGuard使用

    在Google发布的android源码中,面对那么多代码和文件目录,此时该如何混淆代码与配置混淆文件呢?

    android中默认是将代码混淆ProGuard关闭的,在alps/build/core/proguard.flags中有下面一句,意指将默认不混淆,不需要代码删除,我们将这一句注释起来,就起到代码混淆编译的作用。

    1
    2
    # Don't obfuscate. We only need dead code striping.
    -dontobfuscate
    可以说,这句是android工程中代码混淆的总开关,然而,注释了上面的代码后,整个工程就已经是代码混淆了吗?不是的,这里还要关注一个文件alps/build/core/package.mk,在这个文件中有这么一段:

    1
    2
    3
    4
    5
    6
    ifndef LOCAL_PROGUARD_ENABLED
    ifneq ($(filter user userdebug, $(TARGET_BUILD_VARIANT)),)
        # turn on Proguard by default for user & userdebug build
        #LOCAL_PROGUARD_ENABLED :=full
    endif
    endif
    切记:当我们需要对整个工程进行代码混淆的时候,就把此处的 #LOCAL_PROGUARD_ENABLED :=full注释去掉,成为有效的宏即可。如果不想对整个工程代码混淆,而只是相对某个模块混淆的话,就先不要动这里的代码。

    接着建议将真个工程new一遍,之后就可以针对具体的apk文件进行混淆文件的设置和定制了。下面以alps/packages/apps/Music为例说说该如何对特定模块做到混淆代码:

    在Music目录下,我们看到一个平时不太关注,但今天一定很在意的文件名:proguard.flags ,对了,这个文件就是Music的混淆配置文件,可以打开看看(有些地方没有这个文件,用户可以自己手动新建一下,最好名称也叫proguard.flags,android下默认都是这个名字)。当然,设置了配置文件还是不够的,还需要在同目录的Android.mk中如下设置如下两句:

    1
    2
    LOCAL_PROGUARD_ENABLED  := full
    LOCAL_PROGUARD_FLAG_FILES := proguard.flags
    只有这样才能让混淆代码有效,并且将混淆配置文件关联起来。(有些模块没有这两句句,就自己手动加上)

    反之,如果用户已经在alps/build/core/package.mk打开了全工程混淆编译的控制点后,又在针对某个模块时不想混淆编译怎么办?这就简单了,将模块下的Android.mk中设置为**LOCAL_PROGUARD_ENABLED := disabled**即可。

    这样,我们通过mm编译后的代码生成的apk,或者new真个工程后生成的烧机代码,都是已经添加相应配置的混淆代码了。

    反编译后,除过proguard.flags中定制的不需要混淆的代码外,其他都是被混淆了,如图所示是android中Music模块的混淆后反编译结果:

    图片说明文字

    混淆文件的配置

    在实际使用过程中,我们会发现当前apk中的有些方法和类,是要供外部使用的,而此时混淆了名称,外部调用就会报错了,那么怎么解决这个问题?此时就需要我们配置混淆的个性化文件proguard-project.txt(eclipse环境中)或者proguard.flags(android源码环境),在其中去配置不需要混淆的类、方法和变量等。关于混淆文件的具体配置方法,大家可以去搜索下,我这里提供一段网上有人共享的配置代码,这个配置代码保留了工程文件中的Activity、Application、Service、BroadcastReceiver、ContentProvider、BackupAgentHelper、Preference和ILicensingService的子类,并保留了所有的Native变量名及类名,所有类中部分以设定了固定参数格式的构造函数,枚举等等,用来防止外部调用出错,大家可以借鉴下,以后来配置自己的文件:

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    -optimizationpasses 5
    -dontusemixedcaseclassnames
    -dontskipnonpubliclibraryclasses
    -dontpreverify
    -verbose
    -optimizations !code/simplification/arithmetic,!field/*,!class/merging/*

    -keep public class * extends android.app.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

     -keepclasseswithmembernames class * {
         native <methods>;
    }

    -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 {
        public static final android.os.Parcelable$Creator *;
    }
    就写这么多了,有问题和建议,欢迎一起讨论!

    4.2以下版本尝试
         1.android中默认是将代码混淆ProGuard关闭的,在alps/build/core/proguard.flags中有下面一句,意指将默认不混淆,不需要代码删除,我们将这一句注释起来,就起到代码混淆编译的作用。

    1

    2

    # Don't obfuscate. We only need dead code striping.

    -dontobfuscate

                      将上面改为

    1

    2

    # Don't obfuscate. We only need dead code striping.

    #-dontobfuscate

                 2.还要关注一个文件alps/build/core/package.mk,在这个文件中有这么一段:

    1

    2

    3

    4

    5

    6

    ifndef LOCAL_PROGUARD_ENABLED

    ifneq($(filter user userdebug, $(TARGET_BUILD_VARIANT)),)

        # turn on Proguard by defaultfor user& userdebug build

        #LOCAL_PROGUARD_ENABLED :=full

    endif

    endif

                      不动,如果没注释,请注释下,注释为了下面部分加扰,打开应该是全部加扰,没有尝试过

                      3.在自己的工程下下面Android.mk里添加

    LOCAL_PROGUARD_ENABLED  := full

    LOCAL_PROGUARD_FLAG_FILES := proguard.cfg

                      proguard.cfg跟Android.mk同级目录下。

                      4.把源码重新全编译下

    4.4版本  可能还涉及\build\core\java.mk  具体改法在测试中
    4.4的话,还需要改一处才生效

    Build/core/java.mk 里的

    ifeq ($(filter obfuscation,$(LOCAL_PROGUARD_ENABLED)),)

    # By default no obfuscation

    # proguard_flags += -dontobfuscate ――注释掉这句

    endif  # No obfuscation
    展开全文
  • 今天给大家介绍一个开源.net混淆器——ConfuserEx http://yck1509.github.io/ConfuserEx/ 由于项目中要用到.net 混淆器,网上搜寻了很多款,比如Dotfuscator、xeoncode、foxit等等。 但大部分收费,当然也...

    今天给大家介绍一个开源.net混淆器——ConfuserEx

    http://yck1509.github.io/ConfuserEx/

    由于项目中要用到.net 混淆器,网上搜寻了很多款,比如Dotfuscator、xeoncode、foxit等等。

    但大部分收费,当然也有破解版的,公司要求不能用盗版软件。

    找了半天终于找到了ConfuserEX,用起来还行,就赶紧拿出来给大家分享下。

     

    下载地址:https://github.com/yck1509/ConfuserEx/releases

    由于网上中文介绍的比较少,我这里做个测试,给大家演示一下:

    本文不提代码开源,只谈代码混淆方法。 
    本文使用的代码混淆器是ConfuserEx,网上可以下载的到。参考博文:开源.net 混淆器ConfuserEx介绍 
    .Net平台开发的应用程序,大多编译之后,在bin/Debug目录下生成很多.dll文件和一个可执行文件.exe。本文就是对这些.dll文件和.exe文件进行混淆,防止反编译。

    ConfuserEx混淆.dll文件和.exe文件方法不尽相同。方法如下: 
    首先,下载ConfuserEx软件,打开后如下图所示: 
    这里写图片描述 
    (一)混淆.dll文件 
    比如混淆BLL.dll和DAL.dll文件(这是项目中经常编译出来的文件,它们其实是两个类库)

    1.混淆.dll文件 
    将待混淆的.dll文件(单个或多个)拖拽进中间方框区域,如下图所示: 
    这里写图片描述

    2.选择Settings项,添加混淆规则,如下图: 
    这里写图片描述

    3.设置混淆规则 
    Protections选择anti ildasm,应该是防止IL反编译。因为Ildasm.exe是微软提供的.NET的IL反编译器。 
    这里写图片描述 
    所有的.dll文件都设置好混淆规则后,就可以进行下一步了。

    4.选择Proect!选项 
    点击【Protect!】,就开始混淆了。Finished代表混淆完成并成功。 
    这里写图片描述

    以上混淆.dll文件就完成了。 
    用ILSpy看一下混淆结果(ILSpy是一个反编译工具) 
    这里写图片描述

    用.NET Reflector反编译结果: 
    这里写图片描述

    (二)混淆.exe文件 
    用ConfuserEx工具混淆.exe与混淆.dll文件唯一的不同设置项(Settings)那里。 
    1.将待混淆的.exe文件拖拽进中间方框区域,然后选择Settings选项卡,添加混淆规则。 
    这里与.dll文件设置混淆规则不同,要设置Packer项,压缩打包,且不需要编辑规则! 
    这里写图片描述

    2.选择Protect!选项卡,点击【Protect!】

    这里写图片描述

    以上混淆.exe文件就完成了。还是通过ILSpy看一下混淆结果

    ILSpy反编译结果: 
    这里写图片描述

    通过ConfuserEx代码工具,可以很好的混淆.dll文件和.exe文件,实现代码保护。


    展开全文
  • 代码混淆之道(一)

    千次阅读 2017-04-06 10:14:19
    代码混淆是软件保护技术的一种,而且是最重要却又最难以捉摸的一类(这话不是我说的,是Christian Collberg和Jasvir Nagra说的)。 说它难以捉摸是因为很难明确定义,很难设计出切实有效的混淆算法,也很难针对混淆...
    本文原创作者:penguin_wwy,
    本文属i春秋的原创奖励计划,未经许可禁止转载!


    代码混淆是软件保护技术的一种,而且是最重要却又最难以捉摸的一类(这话不是我说的,是Christian Collberg和Jasvir Nagra说的)。
    说它难以捉摸是因为很难明确定义,很难设计出切实有效的混淆算法,也很难针对混淆算法的质量进行评估。
    说它很重要是因为如果能在它定义的问题上取得一致,并设计出强壮的算法,我们就可以解决许多安全和密码学上的实际问题。

    一、程序分析之路
    有过逆向经验的盆友们都会运用各种各样的工具对程序进行分析,比如利用OD对程序进行调试、IDA分析函数的控制流程、分析函数间的调用关系,这些都是分析程序的方法。
    破解者使用的程序分析技术大致可以分为两大类:静态分析——通过分析代码获取信息;动态分析——通过运行程序收集信息。
    对于程序的静态分析又包括但不限于以下几种方法:
    1、控制流分析,也就是画出程序运行的流程图
    2、数据流分析,获得变量使用的保守信息
    3、数据依赖分析,变量间的依赖关系(赋值、使用、判断顺序等等)
    4、别名分析,在程序运行的某个时间上多个变量必然或可能指向同一个内存地址
    5、切片,对目标变量的影响
    6、抽象解析,定性而不是定量的判读(比如偶数A和B,那么 (A + B)% 2 == 0必然成立 )
    动态分析包括但不限于调试、剖分、trace等等手段
    此外反汇编、反编译是对无源码程序分析的必经之路。以上这些是破解者常用的甚至必须的对针对软件进行攻击的手段。

    二、代码混淆的价值
    所谓混淆,就是针对需要被保护的程序P,经过混淆后转换为P',P和P'的行为保持一致,但是攻击者很难从P'中获取想要的信息。这里的很难指攻击者在分析P'时需要付出比P多的资源(时间、人力)才能从P'中获得和P一样的信息,这个可以是验证码、敏感的个人信息、软件核心运行流程等等。
    代码混淆同样也分为针对静态分析的静态混淆和针对动态分析的动态混淆。
    静态混淆在程序执行前代码便固定下来了,典型的比如压扁控制流、复杂化控制流、不透明谓词等。动态混淆自然是执行时代码仍在变化,比如代码自修改、程序状态机等等。

    三、一种简单的混淆算法——OBFLDK算法
    该算法基本思路就是把程序中的一个无条件转移指令替换成调用一个跳转函数的指令。在正常的思维中函数执行完成后应该返回到函数调用位置的下一条指令
     
    而之所以调用函数会返回到函数调用的下一条指令,是因为在call指令执行的时候,next指令的地址被保存起来,也就是函数的返回地址。那么当函数返回的时候,返回地址就会被写入到PC寄存器中,从而开始执行函数调用的下一条指令。如果我们修改了函数的返回地址,那不就意味着我们可以控制函数返回之后下一条被执行指令的地址了吗
     
    可以看到,我们通过一个jump_function保持原有的代码code2——>code3的执行顺序不变,而在紧接jump_function的地方,也就是默认在函数调用后被执行的位置插入的是垃圾代码。那么原有的CFG(控制流图)由
    code1——>code2——>code3
    变成
    code1——>code2——>jump_function——>垃圾代码——>code3
    而这段垃圾代码在程序当中是永远不会被执行的,也就是说我们可以把它写成任何东西都不会影响到程序本身的正确性


    下面我们来做一个简单的例子,为了方便我们计算返回地址的位置,我们可以借助宇宙第一IDE——Vistual Studio的反汇编功能

    首先准备一个灰常简单的函数

    int setFunc(int *val) {
            *val += 5;
            return 0;
    }

    然后我们开始对他进行修改,在return 0之前插入我们的跳转函数和垃圾代码

    int setFunc(int *val) {
            *val += 5;
            jmpFunc();
                     
            getEIP();
            _asm {
                    sub                eax, 05h
                    jmp                eax
            };
            return 0;
    }


    jmpFunc就是跳转函数,这条函数会将返回地址设置为return 0所在的位置

    int jmpFunc() {
            _asm {
                    mov                eax, [ebp+04h]        //取出返回地址
                    add                eax, 0ah                //定位到return 0
                    mov                [ebp+04h], eax        //写回返回地址
            }
            return 0;
    }


    _asm是关键字,花括号内跟随的是汇编代码。
    根据x86的调用规则,函数的返回地址会在保存在栈上EBP+4的位置,把返回地址保存到eax寄存器,然后根据计算将返回地址定位到return 0
    计算过程为设置好断点开始debug,然后alt+8打开VS的反汇编窗口
     
    上一个箭头就是此时eax保存的地址,下一个就是我们希望跳转的位置,计算一下差10个字节,所以给eax加上0ah

    主函数

    int main()
    {
            int a = 10;
            setFunc(&a);
            char *str = "this is good";
            printf("%s\n", str);
            getchar();
            return 0;
    }


    如果执行成功会输出this is good
    至于中间的垃圾代码,我们可以看到是一个死循环
    void getEIP() {
            _asm {
                    xor                eax, eax
                    mov                eax, [ebp+4]
            }
    }

     
    执行成功

    进一步的,我们说过这段垃圾代码可以是任何东西,我们可以在垃圾代码所在的位置上填充任何东西。而由于这些代码紧接在函数调用之后,所以IDA这类的反汇编工具会把这些字节识别为可执行代码
    用010Edit打开我们编译生成的可执行程序,然后找到那段垃圾代码
     
    一共10字节,把他们换成hello world的大写字母
     
    程序可以正常执行,丢到IDA中,找到对应的位置
     
    从D0到D9位置就是我们大写的hello world,但是IDA把它们全都识别为可执行代码。。。WTF!
    展开全文
  • 代码混淆步骤详解

    千次阅读 2017-01-18 15:15:24
    混淆代码可以简化我们的apk大小. Studio混淆:1.开启混淆如果使用的是as写的项目, 那么当我们的项目发布时,需要混淆我们只需要更改build.gradle(Model:app)中的一个配置就行.build.gradle(Model:app):
  • 混淆代码总结

    千次阅读 2017-07-14 16:44:18
    混淆代码网址很棒的网址: 1.Android项目实战(二十五):Android studio 混淆+打包+验证是否成功 2.Android Studio(十一):代码混淆及打包apk 3.Android代码混淆之混淆规则 4.Error:warning: Ignoring Inner...
  • 常用的混淆代码

    2017-10-17 15:11:26
    # umeng push sdk start -dontwarn com.taobao.** -dontwarn anet.channel.** -dontwarn anetwork.channel.** -dontwarn org.android.** -dontwarn org.apache.thrift.** -dontwarn com.xiaomi.** ...
  • 混淆代码

    2018-11-16 11:44:36
    # 代码混淆压缩比,在0~7之间,默认为5,一般不下需要修改 -optimizationpasses 5 # 混淆时不使用大小写混合,混淆后的类名为小写 # windows下的同学还是加入这个选项吧(windows大小写不敏感) -...
  • Android 混淆代码总结

    万次阅读 多人点赞 2015-05-25 09:21:50
    Android 混淆代码总结
  • APP 打包混淆代码

    千次阅读 2015-02-27 16:36:16
    APP项目开发完成之后,当测试人员测试了,没有Bug了,一般情况下,公司会有一些技术人员负责发布、...然而,还有一种方式可以打包混淆APP,那就是 android 通过eclipse混淆代码 打包 + proguard 方式。具体的步骤如下:
  • android混淆代码步骤

    2018-10-11 14:43:59
    第一步: 在app下的build.gradle中添加...minifyEnabled trueshrinkResources true//去掉不用资源 //混淆并去除日志信息 proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'),'proguard-rules....
  • js混淆代码还原

    万次阅读 2018-09-07 14:45:48
    js混淆代码还原 - js反混淆:利用js进行赋值实现  案例测试代码如下: eval(function(p,a,c,k,e,d){e=function(c){return(c&lt;a?"":e(parseInt(c/a)))+((c=c%a)&gt;35?String.fromCharCode(c+...
  • 混淆代码恢复

    2019-06-14 05:33:59
    2019独角兽企业重金招聘Python工程师标准>>> ...
  • Springboot+proguard+maven 混淆代码

    千次阅读 2018-12-25 09:27:57
    最近开发的项目要进行试点,为了防止代码很容易被反编译而造成泄露,故而进行了代码混淆的研究,... 我混淆代码使用的是proguard-maven-plugin这个插件,所有proguard的指令都可以在pom中实现。首先要说的是通过这...
  • Android混淆代码所遇到的坑

    千次阅读 2018-04-25 22:29:09
    前言 之前一直没有处理过代码混淆,只了解一些相关的知识...第一步: 在使用混淆代码之前,需要在gradle文件中更改一些配置,需要更改的配置如下:buildTypes { release { minifyEnabled true proguardFiles g...
  • Android从2.3的SDK开始,将ProGuard混淆代码的功能加入了进来。  我们可以从android sdk的tools目录下看到有一个proguard目录。说明具有了代码混淆的功能。    至于如何进行代码的混淆。我们需要做的很...
  • Android混淆代码错误堆栈还原

    千次阅读 2016-10-24 09:26:53
    答案非常简单,只要稍微实践下你就明白了,下面就是给你整理的对混淆代码错误堆栈还原的方法。如何混淆?Android Studio实现混淆很简单,只需要在build.gradle进行如下配置即可: buildTypes { release {
  • 踩坑锦集 1. Caused by: org.apache.maven.plugin.MojoExecutionException: Obfuscation failed (result=1) 这个错误最常见 其实使用mvn插件最常见的错误都是这个的,使用插件失败其实没什么用 可以使用 mvn clean ...
  • Android studio 混淆代码

    2015-10-27 03:38:37
    混淆代码直接报 Information:Gradle tasks [:app:assembleRelease] :MyLibray:compileLint :MyLibray:copyReleaseLint UP-TO-DATE :MyLibray:preBuild UP-TO-DATE :MyLibray:preReleaseBuild UP-TO-DATE :MyLibray:...
  • C#使用Dotfuscator混淆代码的加密方法

    千次阅读 2017-03-23 19:35:36
    C#编写的代码如果不进行一定程度的混淆和加密,那么是非常容易被反编译进行破解的,特别是对于一些商业用途...使用Dotfuscator可以实现混淆代码、变量名修改、字符串加密等功能。 这里介绍的是DotfuscatorP
1 2 3 4 5 ... 20
收藏数 208,999
精华内容 83,599
关键字:

混淆代码