精华内容
参与话题
问答
  • 混淆

    2018-07-03 09:57:36
    -optimizationpasses 5 #指定代码的压缩级别#包明不混合大小写-dontusemixedcaseclassnames#不去忽略非公共的库类-dontskipnonpubliclibraryclasses #优化 不...混淆时所采用的算法-optimizations !code/simplific...
    -optimizationpasses 5 #指定代码的压缩级别
    #包明不混合大小写
    -dontusemixedcaseclassnames
    #不去忽略非公共的库类
    -dontskipnonpubliclibraryclasses
     #优化  不优化输入的类文件
    -dontoptimize
     #预校验
    -dontpreverify
     # 混淆时所采用的算法
    -optimizations !code/simplification/arithmetic,!field/*,!class/merging/*
    #保护注解
    -keepattributes *Annotation*
    # 保持哪些类不被混淆
    -keep public class * extends android.app.Fragment
    -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
    #如果有引用v4包可以添加下面这行
    #-keep public class * extends android.support.v4.app.Fragment
    -keep public class * extends android.support.** { *; }
    #如果引用了v4或者v7包
    -dontwarn android.support.*
    #忽略警告
    -ignorewarning
    #####################记录生成的日志数据,gradle build时在本项目根目录输出################
     #混淆时是否记录日志
    -verbose
    #apk 包内所有 class 的内部结构
    -dump class_files.txt
    #未混淆的类和成员
    -printseeds seeds.txt
    #列出从 apk 中删除的代码
    -printusage unused.txt
    #混淆前后的映射
    -printmapping mapping.txt
    #####################记录生成的日志数据,gradle build时 在本项目根目录输出-end################
    #####混淆保护自己项目的部分代码以及引用的第三方jar包library - start #######
    #如果不想混淆 keep 掉  保留一个完整的包
    #-keep class com.lippi.recorder.iirfilterdesigner.** {*; }
    #项目特殊处理代码
    #忽略警告
    #-dontwarn com.lippi.recorder.utils**
    #如果用用到Gson解析包的,直接添加下面这几行就能成功混淆,不然会报错。
    #//原因分析,可能是高版本的 sdk 通过 proguard 混淆代码时默认已经将 lib目录中的 jar 都已经添加到打包脚本中,所以不需要再次手动添加
    # 混淆jar
    #-libraryjars libs/gson-2.2.4.jar
    # 混淆类
    #-keep class sun.misc.Unsafe { *; }
    # 混淆包
    #-keep class com.google.gson.examples.android.model.** { *; }
    #dialog
    -keep class me.drakeet.materialdialog.** { *; }
    #加载框
    -keep class com.kaopiz.kprogresshud.** { *; }
    #下拉刷新
    -keep class in.srain.cube.views.ptr.** { *; }
    #实体类不混淆
    -keep class com.ousrslook.shimao.commen.ioc.** { *; } #不能混淆 否则注解无效
    -keep class com.ousrslook.shimao.model.** { *; } #不能混淆
    -keep class com.ousrslook.shimao.net.XaResult{ *; }#统一返回的实体类泛型不能混淆
    #-keep class com.ousrslook.shimao.net.** { *; }
    ####混淆保护自己项目的部分代码以及引用的第三方jar包library-end####
    -keep public class * extends android.view.View {
        public <init>(android.content.Context);
        public <init>(android.content.Context, android.util.AttributeSet);
        public <init>(android.content.Context, android.util.AttributeSet, int);
        public void set*(...);
    }
    #保持 native 方法不被混淆
    -keepclasseswithmembernames class * {
        native <methods>;
    }
    #保持自定义控件类不被混淆
    -keepclasseswithmembers class * {
        public <init>(android.content.Context, android.util.AttributeSet);
    }
    #保持自定义控件类不被混淆
    -keepclassmembers class * extends android.app.Activity {
       public void *(android.view.View);
    }
    #保持 Parcelable 不被混淆
    -keep class * implements android.os.Parcelable {
      public static final android.os.Parcelable$Creator *;
    }
    #保持 Serializable 不被混淆
    -keepnames class * implements java.io.Serializable
    #保持 Serializable 不被混淆并且enum 类也不被混淆
    -keepclassmembers class * implements java.io.Serializable {
        static final long serialVersionUID;
        private static final java.io.ObjectStreamField[] serialPersistentFields;
        !static !transient <fields>;
        !private <fields>;
        !private <methods>;
        private void writeObject(java.io.ObjectOutputStream);
        private void readObject(java.io.ObjectInputStream);
        java.lang.Object writeReplace();
        java.lang.Object readResolve();
    }
    #保持枚举 enum 类不被混淆 如果混淆报错,建议直接使用上面的 -keepclassmembers class * implements java.io.Serializable即可
    -keepclassmembers enum * {
      public static **[] values();
      public static ** valueOf(java.lang.String);
    }
    -keepclassmembers class * {
        public void *(android.view.View);
    }
    #不混淆资源类
    -keepclassmembers class **.R$* {
        public static <fields>;
    }
     -keep class **.R$* { *; }
    #避免混淆泛型 如果混淆报错建议关掉
    -keepattributes Signature
    


    展开全文
  • 混淆矩阵是ROC曲线绘制的基础,同时它也是衡量分类型模型准确度中最基本,最直观,计算最简单的方法。 一句话解释版本: 混淆矩阵就是分别统计分类模型归错类,归对类的观测值个数,然后把结果放在一个表里展示...

    简介

    混淆矩阵是ROC曲线绘制的基础,同时它也是衡量分类型模型准确度中最基本,最直观,计算最简单的方法。

    一句话解释版本:

    混淆矩阵就是分别统计分类模型归错类,归对类的观测值个数,然后把结果放在一个表里展示出来。这个表就是混淆矩阵。

     

     

    数据分析与挖掘体系位置

    混淆矩阵是评判模型结果的指标,属于模型评估的一部分。此外,混淆矩阵多用于判断分类器(Classifier)的优劣,适用于分类型的数据模型,如分类树(Classification Tree)、逻辑回归(Logistic Regression)、线性判别分析(Linear Discriminant Analysis)等方法。

    在分类型模型评判的指标中,常见的方法有如下三种:

    1. 混淆矩阵(也称误差矩阵,Confusion Matrix)
    2. ROC曲线
    3. AUC面积

    本篇主要介绍第一种方法,即混淆矩阵,也称误差矩阵。

    此方法在整个数据分析与挖掘体系中的位置如下图所示。

     

    混淆矩阵的定义

    混淆矩阵(Confusion Matrix),它的本质远没有它的名字听上去那么拉风。矩阵,可以理解为就是一张表格,混淆矩阵其实就是一张表格而已。

    以分类模型中最简单的二分类为例,对于这种问题,我们的模型最终需要判断样本的结果是0还是1,或者说是positive还是negative。

    我们通过样本的采集,能够直接知道真实情况下,哪些数据结果是positive,哪些结果是negative。同时,我们通过用样本数据跑出分类型模型的结果,也可以知道模型认为这些数据哪些是positive,哪些是negative。

    因此,我们就能得到这样四个基础指标,我称他们是一级指标(最底层的):

    • 真实值是positive,模型认为是positive的数量(True Positive=TP)
    • 真实值是positive,模型认为是negative的数量(False Negative=FN):这就是统计学上的第二类错误(Type II Error)
    • 真实值是negative,模型认为是positive的数量(False Positive=FP):这就是统计学上的第一类错误(Type I Error)
    • 真实值是negative,模型认为是negative的数量(True Negative=TN)

    将这四个指标一起呈现在表格中,就能得到如下这样一个矩阵,我们称它为混淆矩阵(Confusion Matrix):

    混淆矩阵的指标

    预测性分类模型,肯定是希望越准越好。那么,对应到混淆矩阵中,那肯定是希望TP与TN的数量大,而FP与FN的数量小。所以当我们得到了模型的混淆矩阵后,就需要去看有多少观测值在第二、四象限对应的位置,这里的数值越多越好;反之,在第一、三象限对应位置出现的观测值肯定是越少越好。

    二级指标

    但是,混淆矩阵里面统计的是个数,有时候面对大量的数据,光凭算个数,很难衡量模型的优劣。因此混淆矩阵在基本的统计结果上又延伸了如下4个指标,我称他们是二级指标(通过最底层指标加减乘除得到的):

    • 准确率(Accuracy)—— 针对整个模型
    • 精确率(Precision)
    • 灵敏度(Sensitivity):就是召回率(Recall)
    • 特异度(Specificity)

    我用表格的方式将这四种指标的定义、计算、理解进行了汇总:

    通过上面的四个二级指标,可以将混淆矩阵中数量的结果转化为0-1之间的比率。便于进行标准化的衡量。

    在这四个指标的基础上在进行拓展,会产令另外一个三级指标

     

    三级指标

    这个指标叫做F1 Score。他的计算公式是:

     

    其中,P代表Precision,R代表Recall。

    F1-Score指标综合了Precision与Recall的产出的结果。F1-Score的取值范围从0到1的,1代表模型的输出最好,0代表模型的输出结果最差。

     

     

    混淆矩阵的实例

    当分类问题是二分问题是,混淆矩阵可以用上面的方法计算。当分类的结果多于两种的时候,混淆矩阵同时适用。

    一下面的混淆矩阵为例,我们的模型目的是为了预测样本是什么动物,这是我们的结果:

    通过混淆矩阵,我们可以得到如下结论:

    Accuracy

    在总共66个动物中,我们一共预测对了10 + 15 + 20=45个样本,所以准确率(Accuracy)=45/66 = 68.2%。

    以猫为例,我们可以将上面的图合并为二分问题:

    Precision

    所以,以猫为例,模型的结果告诉我们,66只动物里有13只是猫,但是其实这13只猫只有10只预测对了。模型认为是猫的13只动物里,有1条狗,两只猪。所以,Precision(猫)= 10/13 = 76.9%

    Recall

    以猫为例,在总共18只真猫中,我们的模型认为里面只有10只是猫,剩下的3只是狗,5只都是猪。这5只八成是橘猫,能理解。所以,Recall(猫)= 10/18 = 55.6%

    Specificity

    以猫为例,在总共48只不是猫的动物中,模型认为有45只不是猫。所以,Specificity(猫)= 45/48 = 93.8%。

    虽然在45只动物里,模型依然认为错判了6只狗与4只猫,但是从猫的角度而言,模型的判断是没有错的。

    (这里是参见了Wikipedia,Confusion Matrix的解释,https://en.wikipedia.org/wiki/Confusion_matrix)

    F1-Score

    通过公式,可以计算出,对猫而言,F1-Score=(2 * 0.769 *  0.556)/( 0.769 +  0.556) = 64.54%

    同样,我们也可以分别计算猪与狗各自的二级指标与三级指标值。

     

     

    ROC曲线在R中的实现

    library(ISLR)
    
    cor(Smarket[,-9])
    attach(Smarket)
    
    # logistic Model
    model_LR <- glm(Direction ~ Lag1 + Lag2 + Lag3 + Lag4 + Lag5 + Volume,
                    family = binomial,
                    data = Smarket)
    
    # Make prediction 
    prob_LR <- predict(model_LR, type = 'response', newdata = Smarket[1:300,])
    prob_LR <- predict(model_LR, type = 'response', newdata = Smarket[,])
    
    
    # create a vector of class predictions based on wether the predicted probability of a market increase is greater than or less than 0.5
    pred_LR <- rep("Down" , 1250)          
    pred_LR[prob_LR > 0.5] = 'Up'        
    
    # Confusion Matrix
    table(pred_LR, Direction)
    

     

    展开全文
  • 代码混淆 Flutter的代码混淆 flutter的代码混淆就是混淆dart代码。 代码混淆是修改应用程序二进制文件的过程,以使人们更难以理解。混淆将函数名和类名隐藏在已编译的Dart代码中,从而使攻击者很难对您的专有应用...

    代码混淆

    Flutter的代码混淆

    flutter的代码混淆就是混淆dart代码。
    代码混淆是修改应用程序二进制文件的过程,以使人们更难以理解。混淆将函数名和类名隐藏在已编译的Dart代码中,从而使攻击者很难对您的专有应用程序进行反向工程。

    Flutter代码混淆的做法

    Flutter版本小于1.16

    Android

    将以下行添加到<ProjectRoot> /android/gradle.properties

    extra-gen-snapshot-options=--obfuscate
    

    有关混淆Android主机的信息,请参阅“准备发布Android应用”中的启用Proguard

    iOS

    1. 修改build aot调用

    将以下标志添加到 /packages/flutter_tools/bin/xcode_backend.sh文件中的build aot调用中:

    ${extra_gen_snapshot_options_or_none}
    

    如下定义此标志:

    local extra_gen_snapshot_options_or_none=""
    if [[ -n "$EXTRA_GEN_SNAPSHOT_OPTIONS" ]]; then
      extra_gen_snapshot_options_or_none="--extra-gen-snapshot-options=$EXTRA_GEN_SNAPSHOT_OPTIONS"
    fi
    

    在这里插入图片描述
    修改xcode_backend.sh,要记得在build aot里的前一行加“\".

    2.修改发布配置
    <ProjectRoot> /ios/Flutter/Release.xcconfig中,添加以下行:

    EXTRA_GEN_SNAPSHOT_OPTIONS=--obfuscate
    

    Flutter 1.16.2或更高版本

    要混淆应用程序,请使用--obfuscate标志和--split-debug-info标志相结合来构建发行版本。

    --split-debug-info标志指定Flutter可以在其中输出调试文件的目录。该命令生成符号图。目前支持apk,appbundle,ios和ios框架目标。 (master和dev通道支持macos和aar。)例如:

    flutter build apk --obfuscate --split-debug-info=/<project-name>/<directory>
    

    混淆二进制文件后,请保存符号文件。如果以后要取消混淆堆栈跟踪,则需要这个文件。

    请注意,--split-debug-info标志也可以单独使用。实际上,它可以大大减少代码大小。有关应用程序大小的更多信息,请参阅测量应用程序的大小

    读取混淆的堆栈跟踪

    要调试由模糊处理的应用程序创建的堆栈跟踪,请使用以下步骤使其易于阅读:

    1. 找到匹配的符号文件。例如,从Android arm64设备崩溃将需要app.android-arm64.symbols
    2. flutter symbolize命令提供堆栈跟踪(存储在文件中)和符号文件。例如:
    flutter symbolize -i <stack trace file> -d /out/android/app.android-arm64.symbols
    

    ⚠️警告

    在编写最终将成为混淆的二进制代码的应用程序时,请注意以下几点。

    • 依赖于匹配特定类,函数或库名称的代码将失败。例如,以下对Expect()的调用在混淆的二进制文件中将不起作用:
    expect(foo.runtimeType.toString(), equals('Foo'))
    

    参考链接:
    Obfuscating Dart code
    flutter wiki

    展开全文
  • 混淆的文章其实网上也很多,介绍的都很好,但是关于多个module的混淆规则就不是这么详细,有的也是错误的,经过了2天的多次实践以及查阅资料(多次打包和反编译看源码,很费时间啊),终于达到了我的目的。...

    上一篇博客我们详细介绍了反编译工具jadx的使用方法以及对混淆和加固的对比

    博客中我们提到了混淆。混淆的文章其实网上也很多,介绍的都很好,但是关于多个module的混淆规则就不是这么详细,有的也是错误的,经过了2天的多次实践以及查阅资料(多次打包和反编译看源码,很费时间啊),终于达到了我的目的。下面来总结一下。也希望能帮到需要的同学。

    Android Studio本身集成了ProGuard混淆工具,我们可以通过编辑build.gradle文件来开启混淆并且对代码进行压缩,对资源进行优化等。如下图

    这里写图片描述

    下面是代码,可以直接复制

        buildTypes {
            release {
                minifyEnabled true   //开启混淆
                zipAlignEnabled true  //压缩优化
                shrinkResources true  //移出无用资源
                proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' //默认的混淆文件以及我们指定的混淆文件
            
            }
    
        }
    

    开启了混淆别忘去proguard-rules.pro文件编辑混淆规则,混淆规则网上也有很多,自行百度即可。

    这里写图片描述

    如果你的项目只有一个app module,那么这样配置混淆就可以了。但是如果你的项目有好几个module,module之间还是相互依赖的,那么该怎么混淆呢?

    混淆方法

    1)在app module中统一配置混淆规则
    我们可以直接在app module中build.gradle文件配置所有module需要混淆的规则。这样,其他module中就无需开启混淆。但是并不推荐使用这种方法,当我们取消依赖某些module的时候,这样很容易造成混淆规则冗余,我们还需要删除掉该module相关的混淆配置,很麻烦。

    2)各个module单独配置混淆规则(推荐)
    我们也可以单独为module配置混淆规则,比较推荐这种做法。每个module管理自己的混淆文件,当我们不依赖该module的时候,就不会发生第一种方法出现的问题了。

    我们把app module称作为主模块,其依赖的其他module称作为子模块

    如图所示。我的app模块是依赖了其他模块的,其他模块也有相互依赖的地方。

    这里写图片描述

    网上很多关于子module的混淆配置是错误的,经过我的多次实践得出,主模块的混淆开关配置会直接影响到子模块,也就是说如果你的主模块开启的混淆,就算你的子模块关闭混淆开关,最终子模块还是会被混淆的。
    其次
    子模块混淆文件的指定是通过consumerProguardFiles这个属性来指定的,并不是proguardFiles 属性,而且我们无需配置其他的选项,只需要配置consumerProguardFiles属性就可以。该属性表示在打包的时候会自动寻找该module下我们指定的混淆文件对代码进行混淆。

    如果我们发布出一些开源库去给别人用,想要对库代码进行混淆的话,也可以通过配置该属性来达到目的

    这里写图片描述

    关于多模块混淆的小技巧

    一般来说,在组件化开发的情况下,app module的代码是很少的,依赖的第三方库也是很少的。我们可以把通用的混淆规则放到app module中。 这样子module就无需配置通用混淆规则,只需要配置一些该module所需要的混淆规则即可。大大减少了混淆代码。

    app module下的混淆规则
    这里给出一个也是从网上找的基本的混淆模板。关于自己项目的实体类和依赖的第三方sdk需要自己添加混淆规则,一般开源库都会给出混淆规则,没有的话就要自己百度了

    #
    #-------------------------------------------基本不用动区域----------------------------------------------
    #
    #
    # -----------------------------基本 -----------------------------
    #
    
    # 指定代码的压缩级别 0 - 7(指定代码进行迭代优化的次数,在Android里面默认是5,这条指令也只有在可以优化时起作用。)
    -optimizationpasses 5
    # 混淆时不会产生形形色色的类名(混淆时不使用大小写混合类名)
    -dontusemixedcaseclassnames
    # 指定不去忽略非公共的库类(不跳过library中的非public的类)
    -dontskipnonpubliclibraryclasses
    # 指定不去忽略包可见的库类的成员
    -dontskipnonpubliclibraryclassmembers
    #不进行优化,建议使用此选项,
    -dontoptimize
     # 不进行预校验,Android不需要,可加快混淆速度。
    -dontpreverify
    
    
    # 屏蔽警告
    -ignorewarnings
    # 指定混淆是采用的算法,后面的参数是一个过滤器
    # 这个过滤器是谷歌推荐的算法,一般不做更改
    -optimizations !code/simplification/arithmetic,!field/*,!class/merging/*
    # 保护代码中的Annotation不被混淆
    -keepattributes *Annotation*
    # 避免混淆泛型, 这在JSON实体映射时非常重要
    -keepattributes Signature
    # 抛出异常时保留代码行号
    -keepattributes SourceFile,LineNumberTable
     #优化时允许访问并修改有修饰符的类和类的成员,这可以提高优化步骤的结果。
    # 比如,当内联一个公共的getter方法时,这也可能需要外地公共访问。
    # 虽然java二进制规范不需要这个,要不然有的虚拟机处理这些代码会有问题。当有优化和使用-repackageclasses时才适用。
    #指示语:不能用这个指令处理库中的代码,因为有的类和类成员没有设计成public ,而在api中可能变成public
    -allowaccessmodification
    #当有优化和使用-repackageclasses时才适用。
    #-repackageclasses com.test
    
     # 混淆时记录日志(打印混淆的详细信息)
     # 这句话能够使我们的项目混淆后产生映射文件
     # 包含有类名->混淆后类名的映射关系
    -verbose
    
    #
    # ----------------------------- 默认保留 -----------------------------
    #
    #----------------------------------------------------
    # 保持哪些类不被混淆
    #继承activity,application,service,broadcastReceiver,contentprovider....不进行混淆
    -keep public class * extends android.app.Activity
    -keep public class * extends android.app.Application
    -keep public class * extends android.support.multidex.MultiDexApplication
    -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 * extends android.view.View
    -keep class android.support.** {*;}## 保留support下的所有类及其内部类
    
    -keep public class com.google.vending.licensing.ILicensingService
    -keep public class com.android.vending.licensing.ILicensingService
    #表示不混淆上面声明的类,最后这两个类我们基本也用不上,是接入Google原生的一些服务时使用的。
    #----------------------------------------------------
    
    # 保留继承的
    -keep public class * extends android.support.v4.**
    -keep public class * extends android.support.v7.**
    -keep public class * extends android.support.annotation.**
    
    
    #表示不混淆任何包含native方法的类的类名以及native方法名,这个和我们刚才验证的结果是一致
    -keepclasseswithmembernames class * {
        native <methods>;
    }
    
    
    #这个主要是在layout 中写的onclick方法android:onclick="onClick",不进行混淆
    #表示不混淆Activity中参数是View的方法,因为有这样一种用法,在XML中配置android:onClick=”buttonClick”属性,
    #当用户点击该按钮时就会调用Activity中的buttonClick(View view)方法,如果这个方法被混淆的话就找不到了
    -keepclassmembers class * extends android.app.Activity{
        public void *(android.view.View);
    }
    
    #表示不混淆枚举中的values()和valueOf()方法,枚举我用的非常少,这个就不评论了
    -keepclassmembers enum * {
        public static **[] values();
        public static ** valueOf(java.lang.String);
    }
    
    #表示不混淆任何一个View中的setXxx()和getXxx()方法,
    #因为属性动画需要有相应的setter和getter的方法实现,混淆了就无法工作了。
    -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实现类中的CREATOR字段,
    #毫无疑问,CREATOR字段是绝对不能改变的,包括大小写都不能变,不然整个Parcelable工作机制都会失败。
    -keep class * implements android.os.Parcelable {
      public static final android.os.Parcelable$Creator *;
    }
    # 这指定了继承Serizalizable的类的如下成员不被移除混淆
    -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();
    }
    # 保留R下面的资源
    -keep class **.R$* {
     *;
    }
    #不混淆资源类下static的
    -keepclassmembers class **.R$* {
        public static <fields>;
    }
    
    
    
    # 对于带有回调函数的onXXEvent、**On*Listener的,不能被混淆
    -keepclassmembers class * {
        void *(**On*Event);
        void *(**On*Listener);
    }
    
    # 保留我们自定义控件(继承自View)不被混淆
    -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);
    }
    
    #
    #----------------------------- WebView(项目中没有可以忽略) -----------------------------
    #
    #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);
    }
    #在app中与HTML5的JavaScript的交互进行特殊处理
    #我们需要确保这些js要调用的原生方法不能够被混淆,于是我们需要做如下处理:
    -keepclassmembers class com.ljd.example.JSInterface {
        <methods>;
    }
    
    #(可选)避免Log打印输出
    -assumenosideeffects class android.util.Log {
       public static *** v(...);
       public static *** d(...);
       public static *** i(...);
       public static *** w(...);
     }
    
    
    
    

    子module下的混淆配置 示例

    只需要配置改module需要的混淆规则即可,注意我这里只是个示例,具体的混淆规则根据你的module来定。

    这里写图片描述

    这样一来,我们就优雅的完成了多module下的混淆配置。

    好了,就这些,希望能帮到你。觉得还行的话点个赞呦。


    如果你觉得本文对你有帮助,麻烦动动手指顶一下,算是对本文的一个认可,如果文中有什么错误的地方,还望指正,转载请注明转自喻志强的博客 ,谢谢!

    展开全文
  • 爬虫反混淆入门--JS混淆之ob混淆

    千次阅读 2020-09-17 17:41:59
    写了好几篇JS逆向的文章,作为一名热爱爬虫的工作者,想必一定会接触到JS混淆,JS混淆有很多种,这里举几个:UglifyJS,JScrambler,jsbeautifier.org,JSDetox,obfuscator.io 等,具体的大家可以看看这篇文章 ...
  • javaScript 压缩混淆混淆

    千次阅读 2019-09-03 23:29:13
    javaScript 压缩混淆混淆压缩混淆的意义1. 压缩2. 混淆如何压缩混淆案例Unicode转义序列(Unicode Escape Sequence)压缩代码(Compact code)转换对象的键(Transform Object Keys)死代码注入(Dead Code ...
  • 2.优化类名混淆重名问题; 3.优化代码和项目结构; 更新说明 https://gitee.com/zfj1128/ZFJObsLib_dmg ----------------------------------------分割线-------------------------------------...
  • 本篇文章:自己在混淆的时候整理出比较全面的混淆方法,比较实用,自己走过的坑,淌出来的路。请大家不要再走回头路,可能只要我们代码加混淆,一点不对就会导致项目运行崩溃等后果,有许多人发现没有打包运行好好地...
  • Java代码怎么进行混淆 Java代码怎么进行混淆 Java代码怎么进行混淆 Java代码怎么进行混淆 Java代码怎么进行混淆 Java代码怎么进行混淆 Java代码怎么进行混淆 Java代码怎么进行混淆
  • Anroid混淆混淆反射

    千次阅读 2018-02-07 11:23:37
    今天说android混淆,有点老生常谈了. 但是其实是想说混淆反射 正常开启混淆后,项目中的所有文件都是要被混淆掉,如果说项目中用到了反射,混淆编译后,就会出现反射到的资源文件找不到.所以就要让反射不能被混淆 网上...
  • 代码混淆

    2017-01-05 15:00:58
    代码混淆 首先,在你的工程目录下,找到proguard-rules.pro文件,它就是你要进行编写混淆配置的文件: 光编写该文件还不够哦,你还需要在你module的build.gradle文件中引用该混淆文件: 好了,知道在哪配置...
  • 可能资源被反编译影响还不是很大,而重新打包又由于有签名的保护导致很难被盗版,但代码被反编译就有可能会泄漏核心技术了,因此一款安全性高的程序最起码要做到的一件事就是:对代码进行混淆混淆代码并不是让...
  • Android混淆

    千次阅读 2016-09-27 18:24:38
    混淆(安全战)proguard 由于Java代码是很容易被反编译出来,看到你的源码。因此为了更好的保护我们的源码,我们需要对编译好的class,进行混淆处理。ProGuard混淆代码的开源地址 混淆的语法-include {filename} ...
  • 混淆矩阵

    千次阅读 2019-05-22 08:46:02
    混淆矩阵(confusion matrix)衡量的是一个分类器分类的准确程度。理解其概念本身容易理解,但一些特定术语易被混淆混淆矩阵适用于包含多个分类器的问题,本文为了让读者理解更加容易,以二元分类的混淆矩阵为例...
  • 混淆现已成为开发人员必备的技能,虽然混淆并不能完全避免被破解,但是可以增加反编译的成本,减少多数的人反编译查看代码逻辑想法。而且能减少apk的体积,添加混淆之后,没有用到的资源都不会打包,特别在项目迭代...
  • 文章目录前言一、什么是packed混淆?二、破解方法三、方法验证方法一方法二总结 前言 上一篇讲的ob混淆https://blog.csdn.net/qq_26079939/article/details/108644855,这次给大家带来也是比较常见的一种JS混淆方式...
  • Andorid混淆 aar包混淆

    2019-04-11 10:29:05
    (一下内容参照网络博文加上自己的部分填坑。如有侵权,请联系我...app和aar包混淆: android { ... buildTypes { release { minifyEnabled true proguardFiles getDefaultProguardFile('proguard-android....
  • sdk混淆

    2018-10-17 15:47:41
    项目中sdk的混淆注意点步骤混淆规则 步骤 在需要混淆的module内 打开 其中名字为 build.gradle的文件 在android闭包中 buildTypes下 的release或者debug中添加如下代码 release或者debug影响的是在release包还是...
  • 混淆中再混淆

    2015-11-18 17:10:03
    上篇文章讲了如何混淆,那怎么样才能再混淆呢 以下是我参照另一篇博客中的内容 使用jd-gui查看class文件的时候,经常会发现有一些方法或类,无法正常的显示出来。  我们可以利用这个bug,来阻止jd-gui反编译...
  • 橘光混淆工具-iOS混淆工具 链接导航 工具使用教程-OC 工具使用教程-Flutter 摘要 iOS混淆 iOS代码混淆 iOS过审工具 iOS上架 iOS代码混淆工具 iOS工具 iOS马甲包 iOS马甲包工具 iOS混淆 iOS过4.3 iOS过审 iOS ...
  • android混淆

    2018-09-28 16:11:57
    Android Studio 代码混淆(你真的会混淆吗)  fuck两点水 关注 2017.04.18 20:37* 字数 727 阅读 1403评论 1喜欢 44 一、前言 今天要打包新产品,突然忘了混淆的参数是怎么写的了,虽然之前也混淆过,可是具体...
  • Android代码混淆混淆规则

    万次阅读 热门讨论 2015-02-18 14:51:44
    因为Android是使用Java开发的,所以开发者可以使用ProGuard对代码进行混淆。SDK已经集成了ProGuard工具,开发者可以从SDK目录下的\tools\proguard目录中进行查看。  ProGuard是一个免费的Java类文件收缩,优化,...
  • Apk的混淆,这里的混淆分为两种代码混淆和资源文件混淆
  • 请问各位大神,Java的各种混淆工具里面哪个混淆力度比较大? 求各位推荐几个比较好的混淆工具

空空如也

1 2 3 4 5 ... 20
收藏数 54,108
精华内容 21,643
关键字:

混淆