混淆

由于Android的代码大都是Java代码,所以挺容易被反编译的,好在Android ADT为我们集成了混淆代码的工具,一来可以混淆我们的代码,让程序被反编译后基本看不懂,另外还能起到代码优化的作用。发布项目前,建议打开Android的代码混淆功能。

Android ADT主要通过ProGuard工具来提供代码混淆,网上也有挺多博客文章讲这个的,但感觉很多都介绍得太过于复杂,这里我就以问答的方式来更加简洁地介绍下ProGuard吧。

1. ProGuard是什么

ProGuard是一个工具,用来混淆和优化Java代码。

工作方式:移除无效的代码,将代码中的类名、函数名替换为晦涩难懂的名字。

注意,它只能混淆Java代码,Android工程中Native代码,资源文件(图片、xml),它是无法混淆的。

2. 如何开启ProGuard

修改Android工程根目录下的project.properties文件,把proguard.config=....这一行前面的注释“#”去掉。

这一行指定了系统默认的proguard配置文件,位于Android SDK/tools/proguard目录下。

当然,你也可以自己编写配置文件,但不建议这样做,因此系统默认的配置已经涵盖了许多通用的细节,如果你还有额外的配置,可以添加在 proguard-project.txt 文件中。

注意: 只有在生成release版本的apk时,混淆配置才会起作用,debug版本的apk不会进行混淆。

3. 哪些内容需要手动配置

系统默认的配置已经涵盖了大部分的内容,但是如果你的工程中有如下内容,则需要手动添加配置到proguard-project.txt文件中。

(1) 只在 AndroidManifest.xml 引用的类

(2) 通过JNI回调方式被调用的函数

(3) 运行时动态调用的函数或者成员变量

(4) 当然,如果你不确定哪些需要手动配置,可以以默认的配置生成程序,当运行中发现ClassNotFoundException异常时,即可找到哪个类不该被混淆。

4. 手动配置的规则

手动添加的配置,一般以“-keep”开头,常用的配置命令分别示例如下:

假设Android工程中有一个接口和一个类:

package com.ticktick.example;																																																																																					 public interface TestInterface {	public void test();}																																																																																		public class Test {																																																																																				private String mTestString;	private final int mMinValue;	private final int mMaxValue;																																																																																				public Test( int min, int max){		mMinValue = min;		mMaxValue = max;	}																																																																																							public int getMinValue() {		return mMinValue;	}																																																																																				 	public int getMaxValue() {		return mMaxValue;	}																																																																																				 	public void setTestString(String testStr ) {		mTestString = testStr;	}}

(1) 不混淆某个类的构造函数

例如:不混淆Test类的构造函数:

-keepclassmembers classcom.ticktick.example.Test {public <init>(int,int);}

(2) 不混淆某个包所有的类或指定的类

例如,不混淆package com.ticktick.example下的所有类/接口

-keep class com.ticktick.example.** { * ; }

例如,不混淆com.ticktick.example.Test类:

-keep class com.ticktick.example.Test { * ; }

如果希望不混淆某个接口,则把上述命令中的class替换为interface即可。

(3) 不混淆某个类的特定的函数

例如:不混淆com.ticktick.example.Test类的setTestString函数:

-keepclassmembers classcom.ticktick.example.Test {public void setTestString(java.lang.String);}

(4) 不混淆某个类的子类,某个接口的实现

例如:不混淆com.ticktick.example.Test类的子类

-keep public class * extends com.ticktick.example.Test

例如:不混淆com.ticktick.example.TestInterface的实现

-keep class * implementscom.ticktick.example.TestInterface {public static final com.ticktick.example.TestInterface$Creator *;}

(5) 添加第三方依赖包

例如:添加android-support-v4.jar依赖包

-libraryjarslibs/android-support-v4.jar-dontwarnandroid.support.v4.**{*;}-keep class android.support.v4.**{*;}-keep interface android.support.v4.**{*;}

注意: 需要添加dontwarn,因为默认情况下proguard会检查每一个引用是否正确,但是第三方库里往往有些不会用到的类,没有正确引用,所以如果不配置的话,系统会报错。

5. 混淆后的调试信息解析

当代码混淆之后,输出的Log信息也会带有混淆内容,比如函数名和类名会被替换为晦涩难懂的名字,而与代码中的不一致。

因此,ProGuard工具还提供了恢复混淆内容的工具和文件。

当你开启了ProGuard混淆后,每次生成release版的apk时,Andriod工程的根目录下会对应生成一个proguard文件夹,该文件夹下的mapping.txt文件记录了混淆后的名字与混淆前的名字的对应关系,通过该文件,我们反向得到恢复后的Log信息。

假设Log文件名为log.txt,则恢复混淆的命令为:

$retrace.sh -verbose mapping.txt log.txt

注1:retrace.sh命令位于 <sdk_root>/tools/proguard/目录下

注2:你需要保存每一个release版本的mapping.txt,因为每一次release的混淆结果和映射关系都不一样。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring Boot混淆是一种将Java代码混淆以保护知识产权和源代码的技术。混淆可以使反编译代码变得更加困难,从而使攻击者难以理解和修改代码。以下是一些Spring Boot混淆的方法: 1. 使用ProGuard进行混淆:ProGuard是一个流行的Java混淆器,可以将Java代码压缩和混淆,从而使反编译代码变得更加困难。可以在Spring Boot项目中使用ProGuard插件来进行混淆。 ```java buildscript { dependencies { classpath 'net.sf.proguard:proguard-gradle:6.2.2' } } plugins { id 'net.ltgt.errorprone' version '0.0.15' id 'org.springframework.boot' version '2.5.4' id 'io.spring.dependency-management' version '1.0.11.RELEASE' id 'java' id 'application' id 'com.github.johnrengelman.shadow' version '7.0.0' id 'com.gorylenko.gradle-git-properties' version '2.2.0' id 'org.sonarqube' version '3.3' id 'jacoco' id 'idea' id 'org.springframework.boot.experimental.thin-launcher' version '1.0.26.RELEASE' id 'io.spring.nohttp' version '0.1.2' id 'io.spring.dependency-management' version '1.0.11.RELEASE' id 'io.spring.dependency-management-platform' version '1.0.11.RELEASE' id 'org.springframework.boot.experimental.thin-launcher' version '1.0.26.RELEASE' id 'io.spring.nohttp' version '0.1.2' id 'io.spring.dependency-management' version '1.0.11.RELEASE' id 'io.spring.dependency-management-platform' version '1.0.11.RELEASE' } dependencies { implementation 'org.springframework.boot:spring-boot-starter-web' testImplementation 'org.springframework.boot:spring-boot-starter-test' } task proguard(type: proguard.gradle.ProGuardTask) { configuration 'proguard.conf' injars 'build/libs/spring-boot-app.jar' outjars 'build/libs/spring-boot-app-proguarded.jar' } build.finalizedBy(proguard) ``` 2. 使用Obfuscator进行混淆:Obfuscator是另一种流行的Java混淆器,可以将Java代码压缩和混淆,从而使反编译代码变得更加困难。可以在Spring Boot项目中使用Obfuscator插件来进行混淆。 ```java buildscript { repositories { mavenCentral() } dependencies { classpath 'com.github.wvengen:proguard-gradle:6.2.2' } } plugins { id 'java' id 'application' id 'com.github.johnrengelman.shadow' version '7.0.0' id 'com.gorylenko.gradle-git-properties' version '2.2.0' id 'org.sonarqube' version '3.3' id 'jacoco' id 'idea' id 'org.springframework.boot.experimental.thin-launcher' version '1.0.26.RELEASE' id 'io.spring.nohttp' version '0.1.2' id 'io.spring.dependency-management' version '1.0.11.RELEASE' id 'io.spring.dependency-management-platform' version '1.0.11.RELEASE' } dependencies { implementation 'org.springframework.boot:spring-boot-starter-web' testImplementation 'org.springframework.boot:spring-boot-starter-test' } task obfuscate(type: proguard.gradle.ProGuardTask) { configuration 'proguard.conf' injars 'build/libs/spring-boot-app.jar' outjars 'build/libs/spring-boot-app-obfuscated.jar' } build.finalizedBy(obfuscate) ``` 3. 使用Jscrambler进行混淆:Jscrambler是一种商业混淆器,可以将Java代码压缩和混淆,从而使反编译代码变得更加困难。可以在Spring Boot项目中使用Jscrambler插件来进行混淆。 ```java buildscript { repositories { mavenCentral() } dependencies { classpath 'com.jscrambler:jscrambler-gradle-plugin:5.8.0' } } plugins { id 'java' id 'application' id 'com.github.johnrengelman.shadow' version '7.0.0' id 'com.gorylenko.gradle-git-properties' version '2.2.0' id 'org.sonarqube' version '3.3' id 'jacoco' id 'idea' id 'org.springframework.boot.experimental.thin-launcher' version '1.0.26.RELEASE' id 'io.spring.nohttp' version '0.1.2' id 'io.spring.dependency-management' version '1.0.11.RELEASE' id 'io.spring.dependency-management-platform' version '1.0.11.RELEASE' } dependencies { implementation 'org.springframework.boot:spring-boot-starter-web' testImplementation 'org.springframework.boot:spring-boot-starter-test' } jscrambler { files { source = fileTree('src/main/java') } keys { accessKey = 'your-access-key' secretKey = 'your-secret-key' } params { applicationTypes = 'web' languageSpecifications = 'es6' transformations = 'string-splitting' } } build.finalizedBy(jscrambler) ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值