Android 中的反编译、混淆和加固

很久没写博文了,晚上做噩梦醒来了,顺手写一下吧

反编译

准备工具

  • apktool:
    获取 APK 的资源文件,能够提取 APP 的图片文件和布局文件

下载地址:apktool

  • dex2jar:
    将 classes.dex转化成jar文件

下载地址:dex2jar

  • jd-gui:
    查看APK中classes.dex转化成出的jar文件

下载地址:jd-gui

下载后的 apktool 是一个 jar 文件,你需要在这个 jar 文件的同一目录(最好是英文目录)下创建一个 apktool.bat 文件:

@echo off
if "%PATH_BASE%" == "" set PATH_BASE=%PATH%
set PATH=%CD%;%PATH_BASE%;
chcp 65001 2>nul >nul
java -jar -Duser.language=en -Dfile.encoding=UTF8 "%~dp0\apktool_2.4.0.jar" %*
@pause

其中 apktool_2.4.0.jar 修改为你下载的 jar 文件
这时候你通过 CMD 进入到该目录下,执行 apktool 命令,会看到如下内容:

证明 Apktool 可以使用了

开始反编译

使用ApkTool反编译APK得到xml文件、AndroidManifest.xml和图片

进入到存放 apltool 的目录,执行如下命令:

apktool d -f 你要反编译的apK -o 反编译之后存放的文件路径

你会看到如下界面:

这个时候你的文件夹中就会看到这个 APP 相关的资源文件
包含了:

  • Manifest 清单文件
  • 各种 layout 布局
  • 各种 drawable、color、mipmap 资源等等

使用 dex2jar 将 dex 反编译成 jar

  • 解压之前下载的 dex2jar
  • 解压 APK 文件,你会看到 classes.dex 文件
  • 将 classes.dex 放到 dex2jar 目录
  • MCD 运行 d2j-dex2jar.bat classes.dex

之后你就会看到 classes-dex2jar.jar

使用 jd-gui 阅读 jar 文件内容

这个就不用说了吧

拿到源码之后自然可以为所欲为了,这么看起来,Android 反编译是不是很简单?那我们的 APP 岂不是完全暴露在别人的目光之下?我们的数据如何得到保障呢?

这里就需要用到混淆加密了:

混淆

混淆又叫 花指令,简单来说,混淆就是将我们 APP 当中的一些关键字、类名等修改为无意义的字符串,加大别人阅读代码的难度,从而达到安全的目的。

开启混淆

AndroidStudio 为我们集成了 ProGuard 作为压缩、优化和混淆工具,ProGurad 是一款开源的混淆工具[这里是它的官网],在它的官网中这么形容它:

ProGuard also provides minimal protection against reverse engineering by obfuscating the names of classes, fields and methods.

ProGuard 通过模糊类,字段和方法的名称来提供对逆向工程的最小保护。

我们使用它也十分简单,只需要在 Modulebuild.gradle 中配置即可:

android{
  buildTypes{
    release { 
       minifyEnabled false  //是否进行混淆,默认为 false
       // 混淆文件的位置,其中'proguard-android.txt'为sdk默认的混淆配置,
       //'proguard-rules.pro' 是该模块下的混淆配置
       proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'  
    } 
  }
}

然后我们修改 proguard-rules.pro 自定义我们的混淆规则即可

混淆规则

之前说了,混淆实际上是将类、关键字和方法进行模糊处理,我们制定规则,是要标出那些不需要混淆,那么编译时,ProGurad 会将我们没有标识的内容全部混淆。

  • 为什么不全部混淆呢?

    • 我们暴露给外部 C/C++ 访问的接口需要通过方法名去访问
    • 混淆 R 文件会导致引用错误。

我们要尽最大限度的将代码混淆,因为混淆程度越大,代码阅读越难,但为了保证正常运行,又有一些不能混淆,那么哪些内容不能混淆呢?

  • 自定义控件不参与混淆
  • 枚举
  • 对第三方库中的类
  • 运用了反射的类
  • 使用了 Gson 之类的工具要使 JavaBean 类即实体类不被混淆
  • 在引用第三方库的时候
  • 有用到 WebView 的 JS 调用接口方法
  • Parcelable 的子类和 Creator 静态成员变量不混淆
  • 使用的四大组件,自定义的Application* 实体类
  • JNI中调用的类
  • Layout 布局使用的 View 构造函数(自定义控件)、android:onClick等。

ProGuard常用操作

  • Shrinking:压缩,默认开启,用以减小应用体积,移除未被使用的类和成员,并且会在优化动作执行之后再次执行(因为优化后可能会再次暴露一些未被使用的类和成员)。
-dontshrink #关闭压缩
  • Optimization:优化,默认开启,在字节码级别执行优化,让应用运行的更快。
  -dontoptimize  #关闭优化
  -optimizationpasses n  #表示proguard对代码进行迭代优化的次数,Android一般为5
  • Obfuscation:混淆,默认开启,增大反编译难度,类和类成员会被随机命名,除非用keep保护。
 -dontobfuscate  #关闭混淆
  • keep:跳过,一颗星表示只是保持该包下的类名,而子包下的类名还是会被混淆;
  -keep class com.lixyz.test.*
  • keep:跳过,两颗星表示把本包和所含子包下的类名都保持;
  -keep class com.lixyz.test.**

(上面两种方式保持类后,会发现类名虽然未混淆,但里面的具体方法和变量命名还是变了)

  • keep:跳过,既可以保持该包下的类名,又可以保持类里面的内容不被混淆;
   -keep class com.lixyz.test.*{*;}
  • keep:跳过,既可以保持该包及子包下的类名,又可以保持类里面的内容不被混淆;
   -keep class com.lixyz.test.**{*;}
  • keep:跳过,保持某个类名不被混淆(但是内部内容会被混淆)
   -keep class com.lixyz.BaseDaoImpl
  • keep:跳过,保持某个类的 类名及内部的所有内容不会混淆
  -keep class com.lixyz.BaseDaoImpl{*;}
  • keep:跳过,保持类中特定内容,而不是所有的内容可以使用如下:
  -keep class com.lixyz.gradlestudy.MyProguardBean{
      <init>; #匹配所有构造器
      <fields>;#匹配所有域
      <methods>;#匹配所有方法
  }

上面就保持住了MyProguardBean这个类中的所有的构造方法、变量、和方法

  • 可以在或前面加上private 、public、native等来进一步指定不被混淆的内容
  -keep class com.lixyz.BaseDaoImpl{
      public <methods>;#保持该类下所有的共有方法不被混淆
      public *;#保持该类下所有的共有内容不被混淆
      private <methods>;#保持该类下所有的私有方法不被混淆
      private *;#保持该类下所有的私有内容不被混淆
      public <init>(java.lang.String);#保持该类的String类型的构造方法
  }
  • 在方法后加入参数,限制特定的方法(经测试:仅限于构造方法可以混淆)
  -keep class com.lixyz.gradlestudy.MyProguardBean{
      public <init>(String);
  }
  • 要保留一个类中的内部类不被混淆需要用 $ 符号
  #保持ProguardTest中的MyClass不被混淆
  -keep class com.lixyz.ProguardTest$MyClass{*;}
  • 使用Java的基本规则来保护特定类不被混淆,比如用extends,implement等这些Java规则,如下:保持Android底层组件和类不要混淆
  -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.view.View
  • 如果不需要保持类名,只需要保持该类下的特定方法保持不被混淆,需要使用keepclassmembers,而不是keep,因为keep方法会保持类名。
  #保持ProguardTest类下test(String)方法不被混淆
  -keepclassmembernames class com.lixyz.ProguardTest{
      public void test(java.lang.String);
  }
  • 如果拥有某成员,保留类和类成员
  -keepclasseswithmembernames class com.lixyz.ProguardTest

一个模板,转自:简书 > 一s独秀 > Android混淆

#
#-------------------------------------------基本不用动区域----------------------------------------------
#
#
# -----------------------------基本 -----------------------------
#

# 指定代码的压缩级别 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 ''
 # 混淆时记录日志(打印混淆的详细信息)
 # 这句话能够使我们的项目混淆后产生映射文件
 # 包含有类名->混淆后类名的映射关系
-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>;
}

#
#---------------------------------实体类---------------------------------
#--------(实体Model不能混淆,否则找不到对应的属性获取不到值)-----
#
-dontwarn com.suchengkeji.android.confusiondemo.md.**
#对含有反射类的处理
-keep class com.suchengkeji.android.confusiondemo.md.** { *; }
#
# ----------------------------- 其他的 -----------------------------
#
# 删除代码中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.**


#
# ----------------------------- 第三方 -----------------------------
#
-dontwarn com.orhanobut.logger.**
-keep class com.orhanobut.logger.**{*;}
-keep interface com.orhanobut.logger.**{*;}

-dontwarn com.google.gson.**
-keep class com.google.gson.**{*;}
-keep interface com.google.gson.**{*;}
#        。。。。。。

加固

之前说的混淆可以增加反编译代码的阅读难度,从而达到安全的目的,但反编译技术日新月异,APK 的保护措施也不能停止,现在网上有很多给 APK 加固的技术,本质上是给 APK 穿一件衣服加一层壳。

比较推荐腾讯的 乐固官方地址,相当于在混淆的基础上又多了一层保护。

操作傻瓜式的,就不赘述了,看官网吧。

想要了解原理的,可以戳这个链接:Android中的Apk的加固(加壳)原理解析和实现(转)