精华内容
下载资源
问答
  • 代码混淆

    2017-07-27 10:34:36
    代码混淆可以用于程序源代码,也可以用于程序编译而成的中间代码。比如将代码中的各种元素,如变量、函数、类的名字改写成无意义的名字,使破解者在阅读时无法根据名字猜测其用途,增加反编译的阅读难度。执行代码...
    • 什么是代码混淆?
      代码混淆(Obfuscated code)亦称花指令,是将计算机程序的代码,转换成一种功能上等价,但是难于阅读和理解的形式的行为。代码混淆可以用于程序源代码,也可以用于程序编译而成的中间代码。比如将代码中的各种元素,如变量、函数、类的名字改写成无意义的名字,使破解者在阅读时无法根据名字猜测其用途,增加反编译的阅读难度。执行代码混淆的程序被称作代码混淆器。目前已经存在许多种功能各异的代码混淆器。

    • 代码混淆的方式
      为避免出现盗版,提高应用安全性,技术人员对项目源代码进行了代码混淆。即对源代码文件中的一些类名做了变换,改成了以英文字母命名的名称,这样破解者在阅读时就不容易理解其特指的含义。

    • 代码混淆的利与弊
      这种代码混淆方法简单、便于操作。但也因此会给开发者的调试工作带来困难,开发人员通常需要保留原始的未混淆的代码用于调试。由于混淆是不可逆的,在混淆的过程中一些不影响正常运行的信息将永久丢失,这些信息的丢失会使程序变得更加难以理解。

    展开全文
  • 代码混淆技术

    2021-01-23 11:24:39
    代码混淆可以用于程序源代码,也可以用于程序编译而成的中间代码。执行代码混淆的程序被称作代码混淆器。已经存在许多种功能各异的代码混淆器。 在编译的过程中,有以下流程:源程序 - > 前端 - > 中间代码 ...

    代码混淆技术

          代码混淆亦称花指令,是将计算机程序的代码,转换成一种功能上等价,但是难于阅读和理解的形式的行为。代码混淆可以用于程序源代码,也可以用于程序编译而成的中间代码。执行代码混淆的程序被称作代码混淆器。已经存在许多种功能各异的代码混淆器。

          在编译的过程中,有以下流程:源程序 - > 前端 - > 中间代码 - > 代码优化器 - > 中间代码 - > 代码生成器 - > 目标程序,混淆,就是代码优化器的逆过程。混淆技术分为两类:一类是基于控制流的混淆;一类是基于数据流的混淆。

    • 基于控制流的代码混淆技术

          1.常量展开。编译器在编译时,会把那些在每次运行时总是得到相同常量值的表达式替换为该常量值。对代码进行混淆时,我们可以提取出一些指令的立即数,对其进行展开。

          2.恒等运算。存在一些运算是恒等运算,通过将简洁的指令替换为复杂的指令,可以大大增加分析者的分析难度。

          3.模式替换。窥孔优化的逆操作。通过模式替换实现代码等价转换,此外此过程可以不断重复,实现多次代码混淆。

    • 基于数据流的代码混淆技术

          1.控制流平伸法。控制流平伸法的思想是打消原程序块之间的逻辑关系,使所有块都呈现出具有相同的前趋或后继节点。而在程序执行过程中的控制流主要领先分支变量来决定。每个块是否执行是由分支变量来确定的。

          2.分支插入法。所谓分支程序是指那些不会返回值给调用者的子程序,我们常见的void型函数就是如此。程序中的非条件跳转语句在执行过程中将控制权直接转向它指向的目标地址去执行,而不理会紧跟在其后面的指令是什么。因此如果我们用分支程序来代替程序中出现的非条件跳转语句,并结合CFF方式进行变形,则能将程序变得复杂而难于分析。

          3.基于异常处理构造条件分支。在控制流构造过程中,分支条件明确了代码的走向。如果能够对分支条件进行隐藏,则对于代码反汇编和控制流生成产生不利影响,从而阻碍程序员对代码的分析理解。Popov在2007年提出利用异常处理替换程序的非条件跳转指令以抵抗静态逆向分析思想,国内贾春福等将此思想扩展到程序中的条件跳转。

          OLLVM(Obfuscator-LLVM)是瑞士西北应用科技大学安全实验室于2010年6月份发起的一个项目,该项目旨在提供一套开源的针对LLVM的代码混淆工具,以增加对逆向工程的难度。

          OLLVM支持以下特性:指令替换 -mllvm -sub、虚假控制流 -mllvm -bcf

    、打平控制流 -mllvm -fla、函数(Funtions)注解

          所谓指令替换仅仅是对标准二进制运算(比如加、减、位运算)使用更复杂的指令序列进行功能等价替换,当存在多种等价指令序列时,随机选一择种

    混淆并没有增加更多的安全性,因为通过重新优化可以很容易地把替换的等价指令序列恢复原有形态。然而,提供一个伪随机数,就可以使指令替换给二进制文件带来多样性。可用选项有:

          -mllvm -sub:激活指令替换遍(pass)

          -mllvm -sub_loop=3:在激活指令替换情况下,使用这个选项在一个函数中应用3次指令替换。默认应用1次。

          虚假控制流通过在当前基本块之前添加一个基本块,来修改函数调用流程图。新添加的基本块包含一个不透明的谓语,然后再跳转到原来的基本块。原始的基本块会被克隆,并充满了随机的垃圾指令。可用选项有:

    (1)-mllvm -bcf:激活虚假控制流遍(pass)

    (2)-mllvm -bcf_loop=3:如果虚假控制流被激活,在一个函数中应用三次。默认应用一次。

    (3)-mllvm -bcf_prob=40:如果虚假控制流趟被激活,一个基本块将会以40%的概率被混淆。默认30%。

          控制流打平的目的是将程序的控制流图完全地扁平化。可用选项:

    (1)-mllvm -fla:激活控制流打平

    (2)-mllvm -split:激活基本块划分。提高打平能力。

    (3)-mllvm -split_num=3:如果激活控制流打平,对每一个基本块应用三次控制流打平。默认使用1次。

          函数注解,使用注解可以定制哪个函数参与混淆。

          利用OLLVM代码混淆工具可以方便实现对代码的常规混淆。代码混淆器也会带来一些问题。主要的问题包括:

          被混淆的代码难于理解,难以进行调试和试错。开发人员通常需要保留原始的未混淆的代码用于调试。对于支持反射的语言,代码混淆有可能与反射发生冲突。代码混淆并不能真正阻止逆向工程,只能增大其难度。因此,对于对安全性要求很高的场合,仅仅使用代码混淆并不能保证源代码的安全。

    展开全文
  • Android代码混淆

    2018-02-26 16:08:28
    代码混淆 ... github不支持脚注 ...代码混淆可以用于程序源代码,也可以用于程序编译而成的中间代码。执行代码混淆的程序被称作代码混淆器。目前已经存在许多种功能各异的代码混淆器。混淆配置我们一般

    代码混淆

    如有错误可以QQ邮箱联系,745661590@qq.com
    github不支持脚注

    代码混淆概念1

    代码混淆(Obfuscated code)亦称花指令,是将计算机程序的代码,转换成一种功能上等价,但是难于阅读和理解的形式的行为。代码混淆可以用于程序源代码,也可以用于程序编译而成的中间代码。执行代码混淆的程序被称作代码混淆器。目前已经存在许多种功能各异的代码混淆器。

    混淆配置

    我们一般直接在app的build.gradle文件中设置minifyEnabled true即可;
    我们一般也加上shrinkResources true,打开资源压缩。用shrinkResources true开启资源压缩后,所有未被使用的资源默认被移除。

    android {
        buildTypes {
            release {
                minifyEnabled true//是否启动混淆true:打开;false:关闭
                shrinkResources true//打开资源压缩。
                proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
            }
        }
    }

    设置白名单

    白名单也就是proguard-rules.pro中我们自定义哪些不添加混淆。

    关键字2

    关键字 描述
    dontwarn dontwarn是一个和keep可以说是形影不离,尤其是处理引入的library时.
    keep 保留类和类中的成员,防止被混淆或移除
    keepnames 保留类和类中的成员,防止被混淆,成员没有被引用会被移除
    keepclassmembers 只保留类中的成员,防止被混淆或移除
    keepclassmembernames 只保留类中的成员,防止被混淆,成员没有引用会被移除
    keepclasseswithmembers 保留类和类中的成员,防止被混淆或移除,保留指明的成员
    keepclasseswithmembernames 保留类和类中的成员,防止被混淆,保留指明的成员,成员没有引用会被移除
    [保持命令] [类] {
        [成员] 
    }

    通配符

    去除反斜杠,markDown中我不知道怎么去除

    通配符 描述
    * 匹配任意长度字符,不包含包名分隔符(.)
    ** 匹配任意长度字符,包含包名分隔符(.)
    *** 匹配任意参数类型
    $ 内部类
    \<\init> 匹配类中所有的构造函数
    \<\fields> 匹配类中的所有字段
    \<\method> 匹配类中所有的方法
    匹配任意长度的任意类型参数。比如void test(…)就能匹配任意 void test(String a) 或者是 void test(int a, String b) 这些方法。
    extends 即可以指定类的基类
    implement 匹配实现了某接口的类

    规则使用

    • 不混淆某个类

      -keep public class com.dongdongwu.thor.entry.Test { *; }
    • 不混淆某个包所有的类

      -keep class com.dongdongwu.thor.entry.** { *; }
    • 不混淆某个类的子类

      -keep public class * extends com.dongdongwu.thor.entry.Test { *; }
    • 不混淆所有类名中包含了“model”的类及其成员

      -keep public class **.*model*.** { *; }
    • 不混淆某个接口的实现

      -keep class * implements com.dongdongwu.thor.entry.Test { *; }
    • 不混淆某个类的构造方法

      -keepclassmembers class com.dongdongwu.thor.entry.Test {
          public <init>(); 
      }
    • 不混淆某个类的特定的方法

      -keepclassmembers class com.dongdongwu.thor.entry.Test {
          public void test(java.lang.String); 
      }
    • 不混淆某个类的内部类

      -keep class com.dongdongwu.thor.entry.Test$* {
          *; 
      }

    我总结的

    最新的proguard-android.txt中添加了很多下面已经有的,再添加的时候看看是不是已经有了

    
    #######################-----app中-----############################
    #如果使用了Gson之类的工具要使被它解析的JavaBean类即实体类不被混淆
    
    #######################-----第三方-----############################
    
    #######################-----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 boolean isLoggable(java.lang.String, int);
        public static int v(...);
        public static int i(...);
        public static int w(...);
        public static int d(...);
        public static int e(...);
    }
    
    # 保持测试相关的代码
    -dontnote junit.framework.**
    -dontnote junit.runner.**
    -dontwarn android.test.**
    -dontwarn android.support.test.**
    -dontwarn org.junit.**
    
    #######################-----基本-----############################
    #指定代码的压缩级别 0 - 7(指定代码进行迭代优化的次数,在Android里面默认是5,这条指令也只有在可以优化时起作用。)
    -optimizationpasses 5
    
    #混淆时不会产生形形色色的类名(混淆时不使用大小写混合类名,混淆后类名都为小写)
    -dontusemixedcaseclassnames
    
    #指定不去忽略非公共的库的类
    #默认跳过,有些情况下编写的代码与类库中的类在同一个包下,并且持有包中内容的引用,此时就需要加入此条声明
    -dontskipnonpubliclibraryclasses
    #指定不去忽略非公共的库的类的成员
    -dontskipnonpubliclibraryclassmembers
    
    #Optimization is turned off by default. Dex does not like code run
    #hrough the ProGuard optimize and preverify steps (and performs some
    #of these optimizations on its own).
    #不进行优化,建议使用此选项,不优化输入的类文件(原因见上边的原英文注释)
    -dontoptimize
    #不做预检验,preverify是proguard的四个步骤之一
    #Android不需要preverify,去掉这一步可以加快混淆速度
    -dontpreverify
    
    #屏蔽警告
    -ignorewarnings
    
    #指定混淆是采用的算法,后面的参数是一个过滤器
    #这个过滤器是谷歌推荐的算法,一般不做更改
    -optimizations !code/simplification/arithmetic,!field/*,!class/merging/*
    
    #避免混淆Annotation、内部类、泛型、匿名类
    -keepattributes *Annotation*,InnerClasses,Signature,EnclosingMethod
    
    #表示不混淆声明的两个类,这两个类我们基本也用不上,是接入Google原生的一些服务时使用的
    -keep public class com.google.vending.licensing.ILicensingService
    -keep public class com.android.vending.licensing.ILicensingService
    
    #抛出异常时保留代码行号
    -keepattributes SourceFile,LineNumberTable
    #重命名抛出异常时的文件名称,点击鼠标可以到达错误文件位置
    -renamesourcefileattribute SourceFile
    
    #混淆时是否记录日志
    -verbose
    
    #不混淆R文件中的所有静态字段,以保证正确找到每个资源的id
    -keepclassmembers class **.R$* {
        public static <fields>;
    }
    
    #保留四大组件,自定义的Application等这些类不被混淆
    -keep public class * extends android.app.Activity
    -keep public class * extends android.app.Fragment
    -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 * extends android.view.View
    
    #处理support包
    -keep class android.support.** {*;}
    -dontnote android.support.**
    -dontwarn android.support.**
    
    #保留继承的
    -keep public class * extends android.support.v4.**
    -keep public class * extends android.support.v7.**
    -keep public class * extends android.support.annotation.**
    
    #保留本地native方法不被混淆
    -keepclasseswithmembernames class * {
        native <methods>;
    }
    
    #保留枚举类不被混淆
    -keepclassmembers enum * {
        public static **[] values();
        public static ** valueOf(java.lang.String);
    }
    
    #保持 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();
    }
    
    #保留Parcelable序列化类不被混淆
    -keep class * implements android.os.Parcelable {
        public static final android.os.Parcelable$Creator *;
    }
    
    #see http://proguard.sourceforge.net/manual/examples.html#beans
    #不混淆View中的setXxx()和getXxx()方法,以保证属性动画正常工作
    -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);
    }
    
    #不混淆Activity中参数是View的方法,例如,一个控件通过android:onClick="clickMethodName"绑定点击事件,混淆后会导致点击事件失效
    -keepclassmembers class * extends android.app.Activity {
       public void *(android.view.View);
    }
    
    #保留Keep注解的类名和方法(最新的proguard-android.txt中包括了这个)
    -keep class android.support.annotation.Keep
    -keep @android.support.annotation.Keep class * {*;}
    -keepclasseswithmembers class * {
        @android.support.annotation.Keep <methods>;
    }
    -keepclasseswithmembers class * {
        @android.support.annotation.Keep <fields>;
    }
    -keepclasseswithmembers class * {
        @android.support.annotation.Keep <init>(...);
    }
    
    #第三方jar包不被混淆
    -keep class com.github.** {*;}

    参考文档

    展开全文
  • 代码混淆定义

    2018-06-15 17:01:00
    代码混淆可以用于程序源代码,也可以用于程序编译而成的中间代码。执行代码混淆的程序被称作代码混淆器。目前已经存在许多种功能各异的代码混淆器。 将代码中的各种元素,如变量,函数,类的名字改写成无意义的名字...
    代码混淆(Obfuscated code)亦称花指令,是将计算机程序的代码,转换成一种功能上等价,但是难于阅读和理解的形式的行为。代码混淆可以用于程序源代码,也可以用于程序编译而成的中间代码。执行代码混淆的程序被称作代码混淆器。目前已经存在许多种功能各异的代码混淆器。
    将代码中的各种元素,如变量,函数,类的名字改写成无意义的名字。比如改写成单个字母,或是简短的无意义字母组合,甚至改写成“__”这样的符号,使得阅读的人无法根据名字猜测其用途。重写代码中的部分逻辑,将其变成功能上等价,但是更难理解的形式。比如将for循环改写成while循环,将循环改写成递归,精简中间变量,等等。打乱代码的格式。比如删除空格,将多行代码挤到一行中,或者将一行代码断成多行等等。
    代码混淆器也会带来一些问题。主要的问题包括:
    被混淆的代码难于理解,因此调试以及除错也变得困难起来。开发人员通常需要保留原始的未混淆的代码用于调试。对于支持反射的语言,代码混淆有可能与反射发生冲突。代码混淆并不能真正阻止反向工程,只能增大其难度。因此,对于对安全性要求很高的场合,仅仅使用代码混淆并不能保证源代码的安全。
     
    Java是一种跨平台的、解释型语言,Java源代码编译成中间“字节码”存储于class文件中。由于跨平台的需要,Java字节码中包括了很多源代码信息,如变量名、方法名,并且通过这些名称来访问变量和方法,这些符号带有许多语义信息,很容易被反编译成Java源代码。为了防止这种现象,我们可以使用Java混淆器对Java字节码进行混淆。
    混淆就是对发布出去的程序进行重新组织和处理,使得处理后的代码与处理前代码完成相同的功能,而混淆后的代码很难被反编译,即使反编译成功也很难得出程序的真正语义。被混淆过的程序代码,仍然遵照原来的档案格式和指令集,执行结果也与混淆前一样,只是混淆器将代码中的所有变量、函数、类的名称变为简短的英文字母代号,在缺乏相应的函数名和程序注释的情况下,即使被反编译,也将难以阅读。同时混淆是不可逆的,在混淆的过程中一些不影响正常运行的信息将永久丢失,这些信息的丢失使程序变得更加难以理解。
    混淆器的作用不仅仅是保护代码,它也有精简编译后程序大小的作用。由于以上介绍的缩短变量和函数名以及丢失部分信息的原因, 编译后jar文件体积大约能减少25% ,这对当前费用较贵的无线网络传输是有一定意义的。

    转载于:https://www.cnblogs.com/wangmengran/p/9188134.html

    展开全文
  • Android ProGuard代码混淆

    千次阅读 2016-10-21 10:52:17
    代码混淆可以用于程序源代码,也可以用于程序编译而成的中间代码。执行代码混淆的程序被称作代码混淆器。目前已经存在许多种功能各异的代码混淆器。 众所周知,Java虽然是编译型的语言,但是由于Java编译后的字节码...
  • Android 代码混淆

    2019-08-27 14:54:36
    一、 代码混淆 什么是代码混淆? 是用于压缩 优化我们的代码 主要作用是移除我们代码中无用的字段 方法名 类还有属性 为什么要代码混淆? 因为Java是一种跨平台、解释性语言.Java源代码的信息被编写成中间的字节码...
  • 代码混淆亦称花指令,是将计算机程序的代码,转换成一种功能上等价,但是难于阅读和理解的形式的行为,代码混淆可以用于程序源代码,也可以用于程序编译而成的中间代码。 一、工具:Proguard \android-sdks\tools\...
  • 代码混淆可以用于程序源代码,也可以用于程序编译而成的中间代码。执行代码混淆的程序被称作代码混淆器。已经存在许多种功能各异的代码混淆器。 将代码中的各种元素,如变量,函数,类的名字改写成无意义的名字。...
  • 代码混淆及android配置

    2020-07-20 19:19:05
    代码混淆可以用于程序源代码,也可以用于程序编译而成的中间代码。执行代码混淆的程序被称作代码混淆器。已经存在许多种功能各异的代码混淆器。 作用: 混淆器的作用不仅仅是保护代码,它也有精简编译后程序大小...
  • 代码混淆详解

    2017-07-25 09:49:58
    什么是代码混淆 Java 是一种跨平台的、解释型语言,Java 源代码编译成中间”字节码”存储于 class 文件中。由于跨平台的需要,Java 字节码中包括了很多源代码信息,如变量名、方法名,并且通过这些名称来访问...
  • Android 代码混淆实战

    千次阅读 2016-04-25 17:40:04
    什么是代码混淆?Java 是一种跨平台的、解释型语言,Java 源代码编译成中间”字节码”存储于 class 文件中。由于跨平台的需要,Java 字节码中包括了很多源代码信息,如变量名、方法名,并且通过这些名称来访问变量和...
  • android代码混淆

    2016-05-16 16:23:13
    什么是代码混淆 Java 是一种跨平台的、解释型语言,Java 源代码编译成中间”字节码”存储于 class 文件中。由于跨平台的需要,Java 字节码中包括了很多源代码信息,如变量名、方法名,并且通过这些名称来访问变量和...

空空如也

空空如也

1 2 3 4 5 ... 17
收藏数 338
精华内容 135
关键字:

中间代码混淆