[springboot] mvn编译实现代码混淆

pom配置

<project>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <!-- 代码混淆插件 -->
            <plugin>
                <groupId>com.github.wvengen</groupId>
                <artifactId>proguard-maven-plugin</artifactId>
                <version>2.0.14</version>
                <executions>
                    <execution>
                        <!-- 混淆时刻，这里是打包的时候混淆 -->
                        <phase>package</phase>
                        <goals>
                            <!-- 使用插件的什么功能，当然是混淆 -->
                            <goal>proguard</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <!-- 是否将生成的PG文件安装部署 -->
                    <attach>true</attach>
                    <!-- 是否混淆 -->
                    <obfuscate>true</obfuscate>
                    <!-- 指定生成文件分类 -->
                    <attachArtifactClassifier>pg</attachArtifactClassifier>
                    <!-- ProGuard配置参数(可引用cfg配置文件) -->
                    <options>
                        <!-- JDK目标版本1.8-->
                        <option>-target 1.8</option>
                        <!-- 不做收缩（删除注释、未被引用代码） -->
                        <option>-dontshrink</option>
                        <!-- 不做优化（变更代码实现逻辑） -->
                        <option>-dontoptimize</option>
                        <!-- 不路过非公用类文件及成员 -->
                        <option>-dontskipnonpubliclibraryclasses</option>
                        <option>-dontskipnonpubliclibraryclassmembers</option>
                        <!--不用大小写混合类名机制-->
                        <option>-dontusemixedcaseclassnames</option>
                        <!-- 优化时允许访问并修改有修饰符的类和类的成员 -->
                        <option>-allowaccessmodification</option>
                        <!-- 确定统一的混淆类的成员名称来增加混淆 -->
                        <option>-useuniqueclassmembernames</option>
                        <!-- 不混淆所有包名，本人测试混淆后WEB项目问题实在太多，毕竟Spring配置中有 大量固定写法的包名 -->
                        <option>-keeppackagenames</option>
                        <option>-adaptclassstrings</option>
                        <!-- <option>-keepdirectories</option> -->
                        <!-- 不混淆所有特殊的类 -->
                        <option>-keepattributes
                            Exceptions,InnerClasses,Signature,Deprecated,SourceFile,LineNumberTable,LocalVariable*Table,*Annotation*,Synthetic,EnclosingMethod</option>
                        <!-- This option will save all original methods parameters in files defined 
                            in -keep sections, otherwise all parameter names will be obfuscate. -->
                        <option>-keepparameternames</option>
                        <option>-keepclassmembers class * {
                            @org.springframework.beans.factory.annotation.Autowired *;
                            @org.springframework.beans.factory.annotation.Value *;
                            }
                        </option>
                        <!-- 混淆这个包下的类 -->
                        <option>-keep class !com.example.** { *; }</option>
                        <!-- 不混淆main方法 -->
                        <option>-keep class com.example.Application { *; }</option>
        
                        <!-- 不混淆所有的set/get方法，毕竟项目中使用的部分第三方框架（例如Shiro）会用到大量的set/get映射 -->
                        <option>-keepclassmembers public class * {void set*(***);*** get*();}</option>
                        <!-- 不混淆包中的所有类以及类的属性及方法，实体包，混淆了会导致ORM框架及前端无法识别 -->
        
                        <!-- 不对包类的类名进行混淆，但对类中的属性和方法混淆 -->
                        <option>-keep class com.example.controller.** </option>
                        <option>-keep class com.example.service.** </option>
        
                        <!-- 不混淆包下的所有类名，且类中的方法和属性也不混淆 -->
                        <option>-keep class com.example.redis.** { *; }</option>
                        <option>-keep class com.example.domain.** { *; }</option>
                        <option>-keep class com.example.dto.** { *; } </option>
                        <option>-keep class com.example.config.**{ *; }</option>
                        <option>-keep class com.example.dao.** { *; }</option>
                        
                    </options>
                    <!--class 混淆后输出的jar包 -->
                    <outjar>${project.build.finalName}-pg.jar</outjar>
                    <!-- 混淆时需要引用的java库，这些库的类不会做混淆 -->
                    <libs>
                        <lib>${java.home}/lib/rt.jar</lib>
                        <lib>${java.home}/lib/jce.jar</lib>
                    </libs>
                    <!-- 需要做混淆的jar或目录 -->
                    <injar>classes</injar>
                    <!-- 输出目录 -->
                    <outputDirectory>${project.build.directory}</outputDirectory>
                
                </configuration>
            </plugin>

        </plugins>
    </build>
</project>

      使用时将上面pom文件中的plugin标签中的内容引入到自己的pom文件中，将具体的包名换成自己的即可。具体的配置注释中都有，使用过程中主要难点是每个包可混淆到哪种程度，具体的情况需要时最好可以自行进行实验进行验证。下面我将我的混淆配置讲解一下：

• <option>-keep class !com.example.** { *; }</option> 是混淆这个包下的类
• 对于controller、service以及定时任务这三个包，我采用的混淆程度为不对类名进行混淆，但是对属性和方法进行混淆
• controller层注意在使用@PathVariable、@RequestParam时需要显式声明参数名
• 对于dao、pojo、dto以及配置类的包，我不进行混淆

       以上的配置是我自己经过一次次尝试发现的所能混淆的最大程度，否则会报错。注意，在proguard-maven-plugin中默认是对类名，属性，方法全部混淆，所以如果全部混淆，则不需要配置这个包即可。我个人的感悟是混淆的程度主要是由于很多类是交由spring管理，所以这些spring bean的类名以及所注入的对象（由spring管理）最好不要混淆类名，否则spring无法识别以及管理，另外就是DAO类，如果是MySQL这种通过Mapper的XML文件映射的类型，最好不要混淆，否则DAO无法找到对应的SQL语句，其他例如Hbase等通过代码查询，读者可尝试进行混淆。一些工具包也是可以进行混淆的，混淆到那种程度读者可进行尝试。

       完成上述配置后，便可以执行maven命令进行打包，最终在target目录下会生成自己项目的jar包以及一个classes-pg.jar的jar包，其中自己项目的jar包是没有混淆代码的jar包，而classes-pg.jar包中的内容才是真正混淆后的代码，将项目的jar包用winrar打开（切记不饿能解压，否则jar包无法运行），进入到classes目录下，将classes-pg.jar中的内容（不包括META-INF文件夹）复制到项目的jar包的classes目录下即可，这样最后的项目的jar包便是进行代码混淆后的jar包，读者可自行反编译观察一下代码混淆的效果，如果启动后报错，读者可根据错误信息修改混淆的类。如果报错的内容是类名冲突之类的，可以尝试在启动类中修改bean命名策略：

@SpringBootApplication
public class ServerApplication {
    public static void main(String[] args) {
        new SpringApplicationBuilder(ServerApplication.class)
                .beanNameGenerator((def,reg)->def.getBeanClassName())
                .run(args);
    }
}

需要注意的问题：

　　1、因为有时候会配置不保持包名或类名，因此一些相关配置文件的内容需要改变，好在ProGuard不是随机生成类名，而是先按照原名称对相同包下类进行排序，混淆后的类名称依次为a.class，b.class，c.class.....

那么问题来了，当包中超过26个类时，默认命名为A.class，B.class，C.class，在某些操作系统下，会不区分class文件名称的大小写，会导致错误(水平所限，未深入探究跟类加载相关)，可加入以下配置避免在超过26个类文件时，命名为aa.class，ab.class，ac.class，而不是原来的大写类名。

<!-- 不用大小写混合类名机制 -->
<option>-dontusemixedcaseclassnames</option>

　　2、打包部署问题。该配置文件打包出来的war中classes文件仍然为正常代码，需要手动解压，将classes-pg.jar中classes替换进去，在工程化管理的情况下，可以在jenkins中配置脚本，自动将混淆后的classes替换进war包

　　3、编译问题，log4j从2.9版本开始支持JDK9，当项目使用较低版本的proguard对代码进行混淆时会出现jdk版本兼容错误

Can't read [D:\proguardConfig\lib\log4j-api-2.10.0.jar] (Can't process class [META-INF/versions/9/org/apache/logging/log4j/util/ProcessIdUtil.class] (Unsupported class version number [53.0] (maximum 52.0, Java 1.8)))

要解决报错需屏蔽log4j中使用java9 api的类。在proguard的配置文件中log4j-api-2.10.0.jar后面加入(!META-INF/versions/9/**.class,!module-info.class)。如果是pom文件的配置，则需要增加如下配置：

<!-- 屏蔽log4j中使用java9 api的类 -->
<option>-libraryjars lib\log4j-api-2.11.2.jar(!META-INF/versions/9/**.class,!module-info.class)</option>

后来我添加了，还是不行，因为maven 会从我的本地仓库去获取jar包，所以这个lib\...jar路径是错误的，需要修改为你本地的maven仓库地址，同时在<configuration>中添加api的排除：

<exclusions>
    <exclusion>
        <artifactId>log4j-api</artifactId>
        <groupId>org.apache.logging.log4j</groupId>
    </exclusion>
</exclusions>

上面这种方式不推荐，后面我去GitHub看了一下将progurad版本改为6.0以上，让其支持jdk1.8以及更好版本；

在ProGuard<configuration>标签中增加ProGuard版本配置：

<proguardVersion>6.0.2</proguardVersion>

并且在ProGuard<plugin>标签中增加依赖：

<dependencies>
    <dependency>
        <groupId>net.sf.proguard</groupId>
        <artifactId>proguard-base</artifactId>
        <version>6.0.2</version>
        <scope>runtime</scope>
    </dependency>
</dependencies>

然后pom同级目录添加proguard.cfg文件，其实就是把以前的<options>标签中的配置放到配置文件中，如下：

# JDK目标版本1.8
-target 1.8
# 不做收缩（删除注释、未被引用代码）
-dontshrink
# 不做优化（变更代码实现逻辑）
-dontoptimize
-ignorewarnings
# 不路过非公用类文件及成员
-dontskipnonpubliclibraryclasses
-dontskipnonpubliclibraryclassmembers
<!--不用大小写混合类名机制
-dontusemixedcaseclassnames
# 优化时允许访问并修改有修饰符的类和类的成员
-allowaccessmodification
# 确定统一的混淆类的成员名称来增加混淆
-useuniqueclassmembernames
# 不混淆所有包名，本人测试混淆后WEB项目问题实在太多，毕竟Spring配置中有 大量固定写法的包名
-keeppackagenames
-adaptclassstrings
# -keepdirectories 
# 不混淆所有特殊的类
-keepattributes
	Exceptions,InnerClasses,Signature,Deprecated,SourceFile,LineNumberTable,LocalVariable*Table,*Annotation*,Synthetic,EnclosingMethod
# This option will save all original methods parameters in files defined in -keep sections, otherwise all parameter names will be obfuscate.
-keepparameternames
-keep interface * extends * { *; }
-keepclassmembers class * {
	@org.springframework.beans.factory.annotation.Autowired *;
	@org.springframework.beans.factory.annotation.Value *;
	}

# 混淆这个包下的类
-keep class !com.example.** { *; }
# 不混淆main方法
-keep class com.example.Application { *; }

# 不混淆所有的set/get方法，毕竟项目中使用的部分第三方框架（例如Shiro）会用到大量的set/get映射 
-keepclassmembers public class * {void set*(***);*** get*();}

# 不对包类的类名进行混淆，但对类中的属性和方法混淆
-keep class com.example.controller.** 
-keep class com.example.service.** 
-keep class com.example.repository.** 

# 不混淆包下的所有类名，且类中的方法和属性也不混淆
-keep class com.example.redis.** { *; }
-keep class com.example.domain.** { *; }
-keep class com.example.dto.** { *; } 
-keep class com.example.config.**{ *; }
-keep class com.example.dao.** { *; }

 

参考资料

• Java代码混淆 - facelessvoidwang
• Maven web项目使用ProGuard进行混淆
• Springboot 代码混淆
• Springboot + proguard + maven 混淆代码
• SpringBoot使用Proguard混淆代码*
• 解决Proguard不支持含有JDK9代码的Jar包混淆问题