软件产品许可证书 Licence 全流程研发（利用非对称加密技术，既安全又简朴 ...

本篇博客对应的代码所在：
Gitee 堆栈所在：https://gitee.com/biandanLoveyou/licence

1、背景介绍

   公司是做软件 SAAS 服务的，一样平常来说软件部署有以下几种常见的模式：
  1、自己研发和部署到自己的云服务器，然后有偿提供账号给客户利用。代码开辟和服务运维都是本公司自己的，客户不须要关心软件的事情。这种模式只须要对提供的账号做权限管控就行。这种模式一样平常适用于客户没有自己的研发团队，或者客户的研发团队不涉及该领域。
  
  2、自己研发，但是须要部署到客户的云服务器或者私有化服务器，但是不交付源代码。这种模式有一个须要考虑的点：一旦部署到客户的云服务器或者私有化服务器，系统就变得不好管控或者说失去了控制。表现在：一旦过了条约有效期，想停掉运行在客户服务器的系统，那就变得很困难，或者对方不配合，或者对方也可以找运维职员自启动（本文先不考虑客户拿到 jar 包反编译源代码的情况，如果条约有代码协议的束缚，那就是违法的）。本篇博客重要针对这种模式做 Licence 研发，让私有化部署的系统变得可管控。
  
  3、自己研发，资助客户部署到指定服务器，并且交付源代码。
  
2、研发思路

2.1 不可行的方案

   1、条约束缚或者口头束缚。一样平常来说，两家公司不合作之后，基本上关系就变得淡漠或者陌路，跟你在一家公司去职的情况差不多。想要口头束缚客户别用你们之前的系统，险些不大概，只要还能用，客户也会偷偷用，实在用不了才会考虑替代方案，这是人之常情。
  2、把“能用”和“不能用”的控制逻辑放在数据库或者设置文件中。这种方案也不太行，懂一点技术人会顺藤摸瓜，把他们的数据库或者设置文件看一下，哪些是重要信息，修改一下，就能继续用了。
  因此，我们须要考虑一个万全之策，既能做到系统的管控，又能做到后期的简朴维护。那就是把控制逻辑嵌入到代码中（本文先不考虑客户拿到 jar 包反编译源代码的情况，如果条约有代码协议的束缚，那就是违法的）。

2.2 什么是证书？

   证书相当于一个许可证，各行各业都有自己的标准和形式。
  

• 你毕业了，能拿到毕业证书，这是对你学历的证实。
  
• 你要出国，要办理护照，这是你合法入镜的证实。
  
• 你要去香港、澳门，要办理港澳通行证。
  
• 你要结婚，去民政局办理结婚证书。等等
  

  软件行业的证书也是因情况而定，可以根据公司的发展来制定属于你们公司的证书。最终解释权都属于你们公司，只要你们公司承认，那就是有效。

2.3 利用证书的方案

思路如下：
   管理背景生成证书 —> 编写证书的校验逻辑并打成 jar 包 —> 把 jar 包嵌入到私有化部署的代码中 —> 考虑证书到期的时间可以方便更换（且无需重启服务） —> 考虑证书到期前的提示
  我们可以用学过的技术，把证书的方案落地。焦点技术采用【非对称加密+拦截器】，旨在“让天下没有难写的代码”。
不懂非对称加密？查看我的博客：利用 Java 原生或 Hutool 工具包编写非对称加解密的工具类-CSDN博客

3、代码实现

3.1 代码结构

说明：
   

• certificate：这是存放证书的目录，在开辟阶段我们方便去做演示。如果现实应用，要考虑 Linux 情况和 docker 情况（须要考虑挂载）。后续如果更换证书，直接用新证书更换旧的证书即可，无需重启服务，对业务没有任何影响。
  
• client：简朴的测试客户端，代码只有几行。
  
• client-offline：私有化部署时的客户端，须要把 core 包打进去，代码也是几行，做演示
  
• core：证书的焦点校验包（重点）
  
• server：管理背景或者用于生成证书的服务，一样平常是业务系统的管理平台。
  

  
3.2 管理背景（服务端）代码实现

管理背景代码结构：

3.2.1 证书模型介绍

证书的模型（实体）我们写在 LicenceEntity 这个实体类，焦点字段如下：

1. public class LicenceEntity implements Serializable {
3.     private static final long serialVersionUID = -4048081970386334457L;
5.     /**
6.      * 证书 ID
7.      */
8.     private String licenceId;
10.     /**
11.      * 证书名称
12.      */
13.     private String licenceName;
15.     /**
16.      * 客户端机器的网卡物理地址
17.      */
18.     private String mac;
20.     /**
21.      * 秘钥（指的是公钥）
22.      */
23.     private String key;
25.     /**
26.      * 证书生效开始日期，格式：yyyy-MM-dd
27.      */
28.     private String effectStartDate;
30.     /**
31.      * 证书生效结束日期，格式：yyyy-MM-dd
32.      */
33.     private String effectEndDate;
35.     /**
36.      * 颁发证书联系人
37.      */
38.     private String contactName;
40.     /**
41.      * 颁发证书人的联系方式
42.      */
43.     private String contactWay;
45.     /**
46.      * 证书所有者
47.      */
48.     private String owner;
50.     /**
51.      * 加密的内容。这个字段是将其它字段加密后的完整内容
52.      */
53.     private String content;
55. }

复制代码

说明
   1、mac：这是客户端的网卡物理所在，每台呆板的物理所在都不一样，基本上可以保证你们公司服务的客户是唯一的。这个 mac 所在，一样平常是负责部署的职员去获取，或者让客户自己提供。这个字段的意义在于：如果你们公司要进行严酷的证书校验，必须是一个证书只允许在一台服务器上利用，那这个字段就显得非常重要。固然，你可以换成自己喜欢的字段名。
  
  2、effectStartDate、effectEndDate：证书的见效起止时间字段。这两个字段是证书的焦点字段，用来判断证书是否在有效期内。
  
  3、key：公钥。根据非对称加密的内容，我们须要把公钥对外，客户端拿到公钥后，可以解密我们用私钥加密的内容。
  
  4、content：证书数据的加密内容。这个字段，是把证书实体转成 JSON 字符串后，再进行非对称加密后的数据。为什么要有这个字段呢？考虑的因素是：①充实利用了非对称加解密的技术，私钥加密的内容只允许公钥解密。如果这个数据被篡改，证书就失效。②别的字段的明文，比如：证书的见效起止时间、证书的联系人等，方便客户拿到证书后，直观的看到这些信息。
  
  5、以上证书的字段，可以根据自己的业务须要去拓展。但是焦点的几个字段，最好能生存。
  3.2.2 焦点实现类

管理背景的焦点，就是准确的生成证书文件 licence.txt，焦点代码如下：

1. package com.study.service.impl;
3. import com.study.constant.CommonKeys;
4. import com.study.entity.LicenceEntity;
5. import com.study.service.LicenceService;
6. import com.study.util.LicenceJsonUtil;
7. import com.study.util.NativeSecurityUtil;
8. import org.slf4j.Logger;
9. import org.slf4j.LoggerFactory;
10. import org.springframework.beans.BeanUtils;
11. import org.springframework.beans.factory.annotation.Value;
12. import org.springframework.scheduling.annotation.Async;
13. import org.springframework.stereotype.Service;
14. import org.springframework.util.StringUtils;
16. import javax.servlet.http.HttpServletResponse;
17. import java.io.BufferedOutputStream;
18. import java.io.IOException;
19. import java.nio.file.Files;
20. import java.nio.file.Path;
21. import java.nio.file.Paths;
22. import java.nio.file.StandardOpenOption;
24. /**
25. * @author CSDN 流放深圳
26. * @description 证书生成核心实现类
27. * @create 2024-04-13 15:55
28. * @since 1.0.0
29. */
30. @Service
31. public class LicenceServiceImpl implements LicenceService {
33.     private static Logger log = LoggerFactory.getLogger(LicenceServiceImpl.class);
35.     /**
36.      * 获取配置文件的私钥
37.      */
38.     @Value("${licence.privateKey}")
39.     private String privateKey;
41.     /**
42.      * 获取配置文件的公钥
43.      */
44.     @Value("${licence.publicKey}")
45.     private String publicKey;
48.     /**
49.      * 创建证书 licence 内容
50.      * @param dtoEntity
51.      * @return
52.      */
53.     @Override
54.     public LicenceEntity createLicence(LicenceEntity dtoEntity) {
55.         LicenceEntity entity = new LicenceEntity();
56.         //赋值相同属性
57.         BeanUtils.copyProperties(dtoEntity, entity);
58.         //content 和 key 需要额外处理
59.         if(StringUtils.isEmpty(privateKey) || StringUtils.isEmpty(publicKey)) return null;
60.         entity.setKey(publicKey);//把公钥放进去，否则客户端无法获取公钥，就无法解密
61.         //把实体转成字符串
62.         String json = LicenceJsonUtil.objectToStr(entity);
63.         //把整个字符串加密
64.         String content = NativeSecurityUtil.encryptByPrivateKey(json, privateKey);
65.         //把加密后的字符串赋值给 content
66.         entity.setContent(content);
67.         return entity;
68.     }
70.     /**
71.      * 下载证书文件
72.      * @param dtoEntity
73.      * @param response
74.      */
75.     @Override
76.     public void downLoadLicence(LicenceEntity dtoEntity, HttpServletResponse response) {
77.         LicenceEntity licenceEntity = createLicence(dtoEntity);
78.         if(null == licenceEntity){
79.             log.error("证书的秘钥未配置！");
80.             return;
81.         }
82.         //把实体转为字符串
83.         String result = LicenceJsonUtil.objectToStr(licenceEntity);
84.         BufferedOutputStream out = null;
85.         try {
86.             //证书文件名
87.             String fileName = CommonKeys.CERTIFICATE_FILE;
88.             response.setContentType("application/octet-stream");
89.             response.setHeader("Content-Disposition", "attachment; filename="" + fileName + """);
90.             response.setCharacterEncoding("UTF-8");
91.             out = new BufferedOutputStream(response.getOutputStream());
92.             out.write(result.getBytes("UTF-8"));
93.             out.flush();
94.         } catch (IOException e) {
95.             log.error(e.getMessage(), e);
96.         } finally {
97.             try {
98.                 if (out != null) {
99.                     out.close();
100.                 }
101.             } catch (Exception e) {
102.                 log.error(e.getMessage(), e);
103.             }
104.         }
106.         //TODO 另外可以保存一份到指定目录下，方便测试（这是使用异步的形式）。上线的时候记得注释掉
107.         saveLicenceToCertificate(result);
109.     }
111.     /**
112.      * 异步保存证书文件到指定目录
113.      * @param result
114.      */
115.     @Async
116.     public void saveLicenceToCertificate(String result){
117.         try{
118.             // 创建证书目录（如果尚未创建）
119.             Path directory = Paths.get(CommonKeys.CERTIFICATE_DIRECTORY);
120.             Files.createDirectories(directory);
121.             // 构建证书文件的完整路径
122.             Path filePath = directory.resolve(CommonKeys.CERTIFICATE_FILE);
123.             // 检查文件是否存在，存在则删掉
124.             Files.deleteIfExists(filePath);
125.             //创建文件（如果文件已经存在，此步骤可能会抛出 FileAlreadyExistsException）
126.             Files.createFile(filePath);
127.             //写入内容到文件，使用 StandardOpenOption.APPEND 可以追加内容而不是覆盖
128.             Files.write(filePath, result.getBytes("UTF-8"), StandardOpenOption.CREATE, StandardOpenOption.WRITE, StandardOpenOption.TRUNCATE_EXISTING);
129.         }catch (Exception e){
130.             log.error(e.getMessage(), e);
131.         }
132.     }
134. }

复制代码

说明：
   1、我们采用私钥加密的方式，把实体转为 JSON 字符串加密后赋值给 content 字段。
  2、对外袒露公钥，用于给客户端拿到证书后，通过公钥解密出 content，然后做校验。
  3.2.3 业务层

案例中的业务层 ServerController 比力简朴，可以根据现实业务中去拓展，这里只做了模拟数据：

1. package com.study.controller;
3. import com.study.entity.LicenceEntity;
4. import com.study.service.LicenceService;
5. import org.springframework.beans.factory.annotation.Autowired;
6. import org.springframework.web.bind.annotation.*;
8. import javax.servlet.http.HttpServletResponse;
9. import java.util.UUID;
11. /**
12. * @author CSDN 流放深圳
13. * @description 控制层
14. * @create 2024-04-13 15:55
15. * @since 1.0.0
16. */
17. @RestController
18. @RequestMapping("/server/licence")
19. public class ServerController {
21.     @Autowired
22.     private LicenceService licenceService;
24.     /**
25.      * 下载证书文件
26.      * 实际项目可以根据前端传递的参数来创建证书字段属性。这里为了测试，直接写测试数据
27.      * @param response
28.      */
29.     @PostMapping("/downLoadLicence")
30.     public void downLoadLicence(HttpServletResponse response){
31.         LicenceEntity dtoEntity = createEntity();
32.         licenceService.downLoadLicence(dtoEntity, response);
33.     }
35.     /**
36.      * 创建测试实体
37.      * @return
38.      */
39.     private LicenceEntity createEntity(){
40.         LicenceEntity entity = new LicenceEntity();
41.         entity.setLicenceId(UUID.randomUUID().toString().replaceAll("-", ""));//证书 ID
42.         entity.setLicenceName("我的 Licence 证书");//证书名称
43.         entity.setMac("");//客户端机器的网卡物理地址，要么留空，要么输入客户端的 Mac 地址
44.         entity.setEffectStartDate("2024-04-15");//证书生效开始日期，格式：yyyy-MM-dd
45.         entity.setEffectEndDate("2025-04-15");//证书生效结束日期，格式：yyyy-MM-dd
46.         entity.setContactName("CSDN 流放深圳");//联系人
47.         entity.setContactWay("https://blog.csdn.net/BiandanLoveyou");//联系方式
48.         entity.setOwner("CSDN 流放深圳");//证书所有者
49.         return entity;
50.     }
52. }

复制代码

说明：
   1、管理背景的业务流程一样平常是先生成证书文件，然后把证书文件下载，给到客户端。
  2、如果须要严酷的校验一个证书对应一台服务器，那就须要赋值 mac 字段
  3、别的字段可以按需赋值
  更多详细详情，请查看源代码。

3.3 证书校验焦点 Jar 代码实现

代码结构：

代码说明：
   1、CheckLicence：证书注解类。一样平常来说，都是全部的接口都要校验证书是否有效，但是在一些场景下，只须要一部分接口校验证书是否有效，比如：可以让客户利用基础的功能，如果涉及到焦点的功能，就须要证书授权。在业务层（Controller）加了这个注解，表现该方法须要校验证书是否有效。固然，还可以通过 yml 设置文件来设置是否全量校验证书。详细看代码。
  
  2、DirectoryInitializer：初始化证书的目录。在项目启动后，会在项目下创建用来存放证书文件的目录，方便程序去找到证书文件来解析。
  
  3、LicenceInterceptor：web拦截器。在哀求进入业务层（Controller）做一个前置的拦截，用来判断证书是否有效，有效才放行。
  
  4、LicenceWebConfig：WebMVC设置类，用来设置 LicenceInterceptor 拦截器。拦截所有的哀求。
  
  5、CommonKeys：定义常量类。
  
  6、LicenceEntity：证书模型实体类。与管理背景的模型字段保持同等。
  
  7、LicenceEnum：证书校验信息枚举类。证书校验会有很多种类的异常，可以在这里同一定义。
  
  8、LicenceExceptionAdvance：全局异常捕捉类。这是企业级开辟基本会有的内容，这里只捕捉了运行时异常。而全局异常捕捉，应该交给外层去处理。
  
  9、LicenceRuntimeException：运行时异常。用来给利用 jar 包的程序抛出运行时异常信息。
  
  10、LicenceJob：证书校验的定时使命类。现在设定 10 分钟执行一次，判断证书是否有效，并把有效（或者无效）的信息放入到内存（LicenceInterceptor 拦截器利用）中。避免每次哀求都去读取证书文件再判断，那样的话性能急剧降低。10分钟的频率还可以接受，如果要更换证书文件，最长的时间窗口就是等待 10 分钟。如果旧的证书还没过期，更换新的证书，那就没有等待期。
  
  11、LicenceCheckServiceImpl：证书校验的焦点实现类。详细看代码，备注齐全！
  
  12、LicenceCheckService：证书校验的接口类。
  
  13、CallResult：接口调用同一返回对象。
  
  14、LicenceDateUtil：Java原生的日期处理工具类。
  
  15、LicenceJsonUtil：Java原生的 JSON 工具类。
  
  16、LicenceSecurityUtil：Java原生的非对称加、解密工具类。
  
  17、MachineAddrUtil：Java原生的呆板信息获取工具类。
  
  说明：这里的工具类全部用 Java 原生的代码编写，重要是避免依靠第三方组件。如果依靠第三方组件，那就要把第三方组件的 Jar 包也打进来，就会导致“胖 Jar 包”，显得臃肿。一样平常来说，良好的开源组件，都是“瘦 Jar 包”，自己封装 Java 原生的代码自己利用，极少引入第三方组件。
  
pom.xml

1.     <dependencies>
2.         <!-- web支持，注意：请一定要在引入该 jar 包的主程序中增加 web 支持（2.x 以上的版本），否则拦截器将失效！！ -->
3.         <dependency>
4.             <groupId>org.springframework.boot</groupId>
5.             <artifactId>spring-boot-starter-web</artifactId>
6.         </dependency>
7.     </dependencies>

复制代码

注意：
   由于 core 焦点包利用到 web 拦截器，所以须要 web 组件的依靠。本项目利用的是 SpringBoot 框架，如果是 SpringMVC 框架则不适用或者 SSH 框架则不适用。
  在 core 的 pom 里加这个依靠，重要是提示利用者，须要在外层的应用中有这个依靠。此依靠的版本要求是 SpringBoot 2.X 以上。
  如果没有加这个依靠，core 的焦点代码就会失效，也就是无法校验证书。
  补充：
  如果 SpringBoot 项目的启动类有加基础包的扫描 @ComponentScan(basePackages = "xx.xxx")，请一定要加上 core 包对应Java类的扫描，否则 Spring 容器无法管理 core 包里的 bean，导致无法校验证书。
  更多详细详情，请查看源代码。

3.4 客户端代码实现及注意事项

3.4.1 client 客户端

代码结构：

说明：
   1、pom.xml 重要是利用 maven 的方式依靠了 core 包，这种方式一样平常是项目都在同一个父级中开辟，直接利用 maven 坐标就可以找到 core 包。

1.     <dependencies>
2.         <!-- core 包的依赖 -->
3.         <dependency>
4.             <groupId>com.study</groupId>
5.             <artifactId>core</artifactId>
6.             <version>1.0.0.RELEASE</version>
7.             <scope>compile</scope>
8.         </dependency>
9.     </dependencies>

复制代码

2、业务层只是简朴校验是否可以访问。由于 core 里面利用了【拦截器】来校验证书，所以只须要一个 Controller 就可以测试证书的有效性了。

1.     @GetMapping("/hello")
2.     public CallResult hello() {
3.         return CallResult.success("证书验证通过!If you can see this message, it means your licence is effective.");
4.     }

复制代码

  
3.4.2 client-offline

代码结构：

说明：
   client-offline 跟 client 差不多。但是须要注意的是，离线版的客户端，须要我们把 core 包打好，复制到 resource 下的 lib 文件夹，然后作为第三方库加入进来利用。
  offline-client 的 pom.xml 代码如下：

1. <?xml version="1.0" encoding="UTF-8"?>
2. <project xmlns="http://maven.apache.org/POM/4.0.0"
3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
5.     <parent>
6.         <artifactId>licence</artifactId>
7.         <groupId>com.study</groupId>
8.         <version>1.0.0.RELEASE</version>
9.     </parent>
10.     <modelVersion>4.0.0</modelVersion>
12.     <artifactId>client-offline</artifactId>
14.     <properties>
15.         <maven.compiler.source>8</maven.compiler.source>
16.         <maven.compiler.target>8</maven.compiler.target>
17.     </properties>
19.     <dependencies>
20.         <dependency>
21.             <groupId>com.study</groupId>
22.             <artifactId>core</artifactId>
23.             <version>1.0.0.RELEASE</version>
24.             <!-- 引用一个本地的 JAR 文件，而不是从 Maven 的中央仓库或其他远程仓库中获取 -->
25.             <scope>system</scope>
26.             <!-- 指定该 JAR 文件的路径 -->
27.             <systemPath>${project.basedir}/src/main/resources/lib/core-1.0.0.RELEASE.jar</systemPath>
28.         </dependency>
29.     </dependencies>
31.     <!-- 构建工具 -->
32.     <build>
33.         <plugins>
34.             <!-- 打包插件 -->
35.             <plugin>
36.                 <groupId>org.springframework.boot</groupId>
37.                 <artifactId>spring-boot-maven-plugin</artifactId>
38.                 <configuration>
39.                     <includeSystemScope>true</includeSystemScope>
40.                 </configuration>
41.             </plugin>
42.         </plugins>
43.     </build>
45. </project>

复制代码

补充：
   请在启动类增加注解：@ComponentScan(basePackages = "com.study")，默认扫描的包，把 core 包加入Spring容器管理。
  
3.5 利用过程详解（保姆式）

3.5.1 启动管理背景，生成证书

启动好管理背景，利用 POST 方式调用接口（利用 Postman 或者 Apipost 工具都可以）：
http://127.0.0.1:9000/server/licence/downLoadLicence
Apipost 测试效果（点击右边箭头处可以下载文档）： 

另外，可以在项目下的 certificate 目录看到 licence.txt 证书文件

3.5.2 启动 client 客户端

可以看到项目启动后，就立刻执行 core 包里的定时使命 LicenceJob 里面校验证书的方法。

访问接口：http://127.0.0.1:8000/client/licence/hello

证书校验通过。

3.5.3 处理  client-offline 客户端

client-offline 是通过导入 core 的 jar 包方式的，然后再通过 maven 坐标依靠进去，所以须要单独处理。
起首把 core 包打出来。在 IDEA 工具右侧 Maven，找到 core 包下的 package，双击：

效果：

去对应的目录下，找到该 jar 包：

把打好的 core-1.0.0.RELEASE.jar 复制出来，粘贴到 client-offline 的 resource 下的 lib 目录下。
这时间 pom.xml 里的设置就会读取到放在 resource 下的 lib 目录下的 jar 包。
启动 client-offline 服务：

 访问接口：http://127.0.0.1:8888/offline/hello
效果（中文乱码不要紧，测试而已）：

至此，完整流程搞定。
   剩下另有几个内容可以自己去验证：
  1、mac 所在，验证一台呆板是否对应一个 licence
  2、验证证书的有效起止时间
  3、@CheckLicence 注解的验证，看下非全量验证的情况下，加与不加 @CheckLicence 注解是否正常放行。
  4、如果客户端不加 core 包须要的 web 依靠，证书验证是否见效
  5、修改证书的部分内容（特别是 content）部分，并且比及下一个定时使命运行，看下证书的校验是否通过。
  
Gitee 堆栈所在：https://gitee.com/biandanLoveyou/licence

—  end —

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。