java进阶：利用trueLicense实现项目离线证书授权
我们要实现的离线校验，实际上就是通过公私钥+证书的形式来实现的，首先生成公私钥，然后利用私钥生成证书，比如x509证书格式，x509证书由用户公共密钥和用户标识符组成。此外还包括版本号、证书序列号、CA标识符、签名算法标识、签发者名称、证书有效期等信息我们的核心目的就是要生成的证书中包含有效期，即可实现授权有效期，然后通过接口拦截器，每次访问接口时利用公钥对证书进行校验，查看证书是否合法、是否在有
·
文章目录
0.引言
我们在实际项目中，会遇到开发的项目部署在服务器上，但可能要控制权限、控制项目授权周期等，部署的环境可能纯内网使用，因此通过网络接口控制就不可行了，我们期望一种分发授权证书的形式，通过部署证书的形式，离线控制用户能使用这个项目的哪个模块、使用多久，甚至使用用户的哪些设备、哪台服务器可以使用。
今天我们来看看这样的需求如何实现
1. trueLicense简介
1.1 原理简介
我们要实现的离线校验，实际上就是通过公私钥+证书的形式来实现的，首先生成公私钥，然后利用私钥生成证书，比如x509证书格式，x509证书由用户公共密钥和用户标识符组成。此外还包括版本号、证书序列号、CA标识符、签名算法标识、签发者名称、证书有效期等信息
我们的核心目的就是要生成的证书中包含有效期，即可实现授权有效期，然后通过接口拦截器，每次访问接口时利用公钥对证书进行校验，查看证书是否合法、是否在有效期内，即可实现我们进行离线控制的目的。
1.2 公钥私钥和证书
部分同学如果没接触过加密和验签的，可能对公私钥和证书没什么概念，所以我们先正对这几个概念做个解释，方便大家理解。
什么是公钥和私钥
公钥和私钥是一对相互匹配的密钥，用于加密和解密数据。 公钥用于加密数据，而私钥用于解密数据。公钥可以公开，任何人都可以使用，而私钥必须保密，只有持有者才能使用。一般会把公钥提供给客户，用于加密，私钥保留在自己侧，用于解密。
那么当自己需要加密数据发送给客户时怎么办呢？ 这就需要客户再生成一对公私钥，由客户保留私钥，我方保留公钥，发送数据时，我们使用客户的公钥加密数据，客户使用自己的私钥进行解密
公私钥一般用于非对称加密中，与对称加密最大的不同就是，对称加密加密方和解密方使用的都是同一个密钥，在密钥交换过程中可能会产生泄漏的风险，而密钥对则只用交换双方的公钥，提高了安全性
公私钥长什么样呢，实际就是两个字符串，当然也可以保存为文件，但实质就是字符串，如下我们生成的一对公私钥，一般私钥会比公钥长：
Private key:
MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAIZDTf1Id19XgnWLfXqFbnKYqM/uzr0/K9EtNJaeQf2CL6cq1kk6AEWjp/j540CWH5qN4RYMzTeomrbPkWYsVvEMzBSNCKqtZSdgQkj8591xcUeiFtjBudzMNdUPRIFqScDgSjci6+Lo01TnFWz/CiuKe/AQJ0xHgpSY06IElYG3AgMBAAECgYBuKh996c347wbeh/wHYiCD6vro0lvUMFc1pU/3HherePy8v4tgPjUm7ufOhMuQnR2FZVEBFLP2LWP1CE+XdF5I7vOl1euc9Wqj+CgQmbFS8lISXbzzgauhL4EQdBOvqggjVnw3NsYWkSU5x+zlR51v2E4mXOalaNEdmpR1MXT+8QJBAMBAKQcqwwD0PZsHIReayGdj8fu4H3PQsOcbCE8GaYh5F0GSByI251B3+RU0whO7fw+gqT8A0FIxt4HV2if6BTsCQQCyyKmPqrlAkPlywdTaEPiSenb8JqMlLsSwFrch0QSmfRZcMjH87ilZSd+DbZstkBZ92xVA40pr3QtOy6lYpn21AkAvz0TkvWOlVxgC97DpF9sCqz5AZTedK6bysixMysFv6P05l0Ei5xh7UHqnJWmmUph0oHW2b1NfPXHvXelUy76FAkAxYGIUH56SSnfaTdYvc8hzDAeYlEMynbwMtflWCZgzMxDd3a8Yn94jntdwQPE+oDDWCY/RH/UJ3T6mQHFA3pqRAkEAwDvPrIZ1+SMqarQMycyYivVbVhAywHmTeNnQ0kgWW080wtvGECJ/UG20xtb3LFGLafqVw1L94hAqKmrh9uct6A==
Public key:
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCGQ039SHdfV4J1i316hW5ymKjP7s69PyvRLTSWnkH9gi+nKtZJOgBFo6f4+eNAlh+ajeEWDM03qJq2z5FmLFbxDMwUjQiqrWUnYEJI/OfdcXFHohbYwbnczDXVD0SBaknA4Eo3Iuvi6NNU5xVs/worinvwECdMR4KUmNOiBJWBtwIDAQAB
什么是证书
电子证书，通常指的是数字证书（Digital Certificate），在信息技术领域，它是一种用于在网络上验证身份和保障通信安全的电子证明。电子证书包含以下几个关键组成部分：
证书持有者的公钥：这是证书的主要部分，用于加密信息，只有证书持有者的私钥可以解密。
证书持有者的身份信息：这包括持有者的名称或其他标识信息，用于验证公钥所属的身份。
证书签发机构的数字签名：证书由一个可信的第三方机构——证书授权中心（Certificate Authority，简称CA）签发。CA通过其私钥对证书内容进行数字签名，以确保证书内容的真实性和完整性。
有效期：证书在特定的时间段内有效，过期后需要更新或更换。
证书使用目的：证书可能用于不同的目的，如网页安全浏览（HTTPS）、电子邮件加密、数字签名等。
电子证书的一般可用于：
身份验证：确认网络上的通信实体是真实的，不是假冒的。
数据加密：使用公钥加密数据，只有持有对应私钥的人才能解密。
数据完整性：确保在传输过程中数据没有被篡改。
证书本身也可以用一串字符串表示，更直观的我们可以在谷歌浏览器上点击左侧地址栏的图标查看网址https证书信息
如下展示了github的证书信息，就可以看到其中包含CA机构、有效期、公钥等基本信息
1.3 trueLicense简介
有了以上基本概念后，我们再来介绍trueLicense：
TrueLicense是一个开源的证书管理引擎，主要用于软件产品的授权管理。它的主要功能是在软件项目交付给客户后，通过签名机制来确保客户不能随意使用该项目。TrueLicense的授权机制基于以下原理：
生成密钥对：使用工具（如KeyTool）生成包含私钥和公钥的密钥对。
授权者保留私钥：授权者使用私钥对包含授权信息（如使用截止日期、MAC地址等）的license进行数字签名。
公钥给使用者：将公钥放在验证代码中使用，用于验证license是否符合使用条件。
TrueLicense的使用场景包括设定软件的试用期、绑定特定IP或MAC地址等。通过这种方式，可以在不修改源代码的情况下，通过重新生成license来延长试用期或修改授权条件。
前面我们提到过，我们的核心目的就是要生成的证书中包含有效期，即可实现授权有效期，然后通过接口拦截器，每次访问接口时利用公钥对证书进行校验，查看证书是否合法、是否在有效期内，而trueLicense就是帮助我们简化这一流程，他内部封装了这一系列的操作，我们只需要简单的集成即可实现功能
下面我们来具体实操。
2. 操作步骤
首先先介绍下，我们本次演示要构造的模块，一共分为3个模块：
- 证书校验模块：集成证书校验核心逻辑，作为工具包引入到需要进行离线授权的服务中
- 证书生成模块：用于生成证书，或对证书进行续约
- 测试模块：单独的一个用于测试离线授权逻辑的模块，模拟需要进行离线授权的web服务
2.1 生成公私钥
2.1.1 keyTool工具介绍
前面提到我们需要生成一个公私钥，然后再生成证书，那么公私钥的生成就可以利用java自带的KeyTool工具来实现
KeyTool 是一个Java密钥和证书管理工具，它是Java SDK的一部分。KeyTool用于管理密钥库（KeyStore），在密钥库中可以存储私钥和公钥证书。以下是KeyTool的一些主要功能和用途：
生成密钥对：KeyTool可以生成密钥对（公钥和私钥），这是加密和安全通信的基础。
管理密钥库：它可以创建和管理密钥库文件，这些文件通常具有.keystore扩展名。密钥库用于存储密钥和证书。
导入和导出证书：KeyTool允许用户将证书导入到密钥库中，或者从密钥库中导出证书。
生成证书请求：可以生成证书签名请求（CSR），这是发送给证书颁发机构（CA）以获取证书的过程的一部分。
查看和管理证书：可以查看密钥库中的证书详细信息，以及设置或更改其属性。
设置别名：在密钥库中，可以为密钥和证书设置别名，以便更容易地引用它们。
以下是KeyTool的一些常用命令：
keytool -genkeypair：生成密钥对。
keytool -list：列出密钥库中的条目。
keytool -importcert：导入证书或证书链。
keytool -exportcert：导出证书。
keytool -keystore：指定密钥库的名称和位置
2.1.2 生成公私钥文件
1、生成私钥库文件（因为keytool基于jdk, 所以需要提前安装jdk），执行后可得到privateKeys.keystore文件
谨记这里的密码库密码storepass为“wu@2024555”，私钥密码keypass为"wu@private2024"，后续还会使用到，私钥别名为“privateKey”
注意这里密码至少由字母和数字组成不少于6位的字符串！
keytool -genkeypair -keysize 1024 -validity 36500 -alias "privateKey" -keystore "privateKeys.keystore" -storepass "wu@2024555" -keypass "wu@private2024" -dname "CN=wu.com, OU=wu, O=wu, L=GUIZHOU, ST=GUIZHOU, C=CN"
| 参数 | 说明 |
|---|---|
-genkeypair | 生成一对非对称密钥 |
-keysize | 密钥长度 |
-validity | 有效期，单位天 |
-alias | 私钥别名 |
-keystore | 私钥文件名 |
-storepass | 访问整个密码库的密码 |
-keypass | 别名对应私钥的密码 |
-dname | 证书持有者详细信息 |
CN=localhost：CN是Common Name的缩写，通常用于指定域名或IP地址
OU=localhost：OU是Organizational Unit的缩写，表示组织单位
O=localhost：O是Organization的缩写，表示组织名
L=SH：L是Locality的缩写，表示城市或地区
ST=SH：ST是State的缩写，表示州或省
C=CN：C是Country的缩写，表示国家代码 |
2、导出别名为"privateKey"的密钥对的证书文件，执行后得到certfile.cer文件
keytool -exportcert -alias "privateKey" -keystore "privateKeys.keystore" -storepass "wu@2024555" -file "certfile.cer"
3、将证书文件导入公钥库，用于生成公钥文件publicCerts.keystore
keytool -import -alias "publicCert" -file "certfile.cer" -keystore "publicCerts.keystore" -storepass "wu@2024555"
4、以上步骤执行完后，我们会得到3个文件，其中文件privateKeys.keystore用来为用户生成License文件，不可泄漏！publicCerts.keystore随应用工程部署到客户服务器，用其解密License文件并校验其许可信息，提供给客户；证书文件certfile.cer文件为临时文件，可删除，后续我们单独用trueLicense生成提供给客户的证书
2.2 license校验模块
注：如下仅贴出核心代码，完整代码可见如下代码仓库：
https://gitee.com/wuhanxue/wu_study/tree/master/demo/license_demo
1、首先定义如下配置路径，用于后续安装、校验证书
license:
# 证书subject
subject: license-test-web
# 公钥别称
publicAlias: publicCert
# 访问公钥库的密码
storePass: wu@2024555
# 证书路径
licensePath: /data/license/license.lic
# 公钥路径
publicKeysStorePath: /data/license/publicCerts.keystore
2、创建springboot项目license-client，删除启动类，将该项目作为核心校验模块，后续引入其他项目中使用，项目依赖及配置如下
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>license-client</artifactId>
<version>1.0.0</version>
<name>license-client</name>
<description>license-client</description>
<properties>
<java.version>1.8</java.version>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<spring-boot.version>2.6.13</spring-boot.version>
<!-- Java Servlet API -->
<javax.servlet-api>4.0.1</javax.servlet-api>
<!-- Apache Commons系列公共库 -->
<commons-lang3>3.7</commons-lang3>
<commons-io>2.6</commons-io>
<commons-codec>1.11</commons-codec>
<!-- Apache HttpClient -->
<httpclient>4.5.5</httpclient>
<!-- Fastjson -->
<fastjson>1.2.47</fastjson>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- Commons -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>${commons-lang3}</version>
</dependency>
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>${commons-io}</version>
</dependency>
<dependency>
<groupId>commons-codec</groupId>
<artifactId>commons-codec</artifactId>
<version>${commons-codec}</version>
</dependency>
<!-- Apache HttpClient -->
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
<version>${httpclient}</version>
</dependency>
<!-- Fastjson -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>${fastjson}</version>
</dependency>
<!-- Java Servlet API -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>${javax.servlet-api}</version>
<scope>provided</scope>
</dependency>
<!-- Jackson对自动解析JSON和XML格式的支持 -->
<dependency>
<groupId>com.fasterxml.jackson.jaxrs</groupId>
<artifactId>jackson-jaxrs-json-provider</artifactId>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.dataformat</groupId>
<artifactId>jackson-dataformat-xml</artifactId>
</dependency>
<!-- SLF4J和LogBack -->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>jcl-over-slf4j</artifactId>
</dependency>
<!-- License -->
<dependency>
<groupId>de.schlichtherle.truelicense</groupId>
<artifactId>truelicense-core</artifactId>
<version>1.33</version>
</dependency>
<dependency>
<groupId>net.sourceforge.nekohtml</groupId>
<artifactId>nekohtml</artifactId>
<version>1.9.22</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
</dependencies>
<dependencyManagement>
<dependencies>
<!-- SpringBoot的依赖配置-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>${spring-boot.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.1</version>
<configuration>
<source>${java.version}</source>
<target>${java.version}</target>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
</plugins>
</build>
</project>
3、创建证书校验配置实体类
@Data
@AllArgsConstructor
@NoArgsConstructor
public class LicenseVerifyParam {
/**
* 证书subject
*/
private String subject;
/**
* 公钥别称
*/
private String publicAlias;
/**
* 访问公钥库的密码
*/
private String storePass;
/**
* 证书生成路径
*/
private String licensePath;
/**
* 密钥库存储路径
*/
private String publicKeysStorePath;
}
4、为了实现还可通设备、ip等控制授权，我们需要创建扩展证书管理器，如不需要的可以省略该步，使用LicenseManager即可
该类中拓展了获取linux、window等系统下ip地址、mac地址、cpu、主板信息等操作，完整类方法可见代码仓库
import com.example.licenseclient.core.LicenseCheckModel;
import com.example.licenseclient.serverinfo.AbstractServerInfos;
import com.example.licenseclient.serverinfo.LinuxServerInfos;
import com.example.licenseclient.serverinfo.WindowsServerInfos;
import de.schlichtherle.license.*;
import de.schlichtherle.xml.GenericCertificate;
import org.apache.commons.lang3.StringUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import java.beans.XMLDecoder;
import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.UnsupportedEncodingException;
import java.util.Date;
import java.util.List;
/**
* @author benjamin5
* @Description 自定义LicenseManager，用于增加额外的服务器硬件信息校验
* @createTime 2024/10/31
*/
public class CustomLicenseManager extends LicenseManager {
private static Logger logger = LogManager.getLogger(CustomLicenseManager.class);
//XML编码
private static final String XML_CHARSET = "UTF-8";
//默认BUFSIZE
private static final int DEFAULT_BUFSIZE = 8 * 1024;
public CustomLicenseManager() {
}
public CustomLicenseManager(LicenseParam param) {
super(param);
}
/**
* @title create
* @description 复写create方法
*/
@Override
protected synchronized byte[] create(
LicenseContent content,
LicenseNotary notary)
throws Exception {
initialize(content);
this.validateCreate(content);
final GenericCertificate certificate = notary.sign(content);
return getPrivacyGuard().cert2key(certificate);
}
/**
* @title install
* @description 复写install方法，其中validate方法调用本类中的validate方法，校验IP地址、Mac地址等其他信息
*/
@Override
protected synchronized LicenseContent install(
final byte[] key,
final LicenseNotary notary)
throws Exception {
final GenericCertificate certificate = getPrivacyGuard().key2cert(key);
System.out.println("certificate.getEncoded() = " + certificate.getEncoded());
notary.verify(certificate);
final LicenseContent content = (LicenseContent) this.load(certificate.getEncoded());
this.validate(content);
setLicenseKey(key);
setCertificate(certificate);
return content;
}
/**
* @title verify
* @description 复写verify方法，调用本类中的validate方法，校验IP地址、Mac地址等其他信息
*/
@Override
protected synchronized LicenseContent verify(final LicenseNotary notary)
throws Exception {
GenericCertificate certificate = getCertificate();
// Load license key from preferences,
final byte[] key = getLicenseKey();
if (null == key) {
throw new NoLicenseInstalledException(getLicenseParam().getSubject());
}
certificate = getPrivacyGuard().key2cert(key);
notary.verify(certificate);
final LicenseContent content = (LicenseContent) this.load(certificate.getEncoded());
this.validate(content);
setCertificate(certificate);
return content;
}
/**
* @title validateCreate
* @description 校验生成证书的参数信息
*/
protected synchronized void validateCreate(final LicenseContent content)
throws LicenseContentException {
final LicenseParam param = getLicenseParam();
final Date now = new Date();
final Date notBefore = content.getNotBefore();
final Date notAfter = content.getNotAfter();
if (null != notAfter && now.after(notAfter)) {
throw new LicenseContentException("证书失效时间不能早于当前时间");
}
if (null != notBefore && null != notAfter && notAfter.before(notBefore)) {
throw new LicenseContentException("证书生效时间不能晚于证书失效时间");
}
final String consumerType = content.getConsumerType();
if (null == consumerType) {
throw new LicenseContentException("用户类型不能为空");
}
}
/**
* @title validate
* @description 复写validate方法，增加IP地址、Mac地址等其他信息校验
*/
@Override
protected synchronized void validate(final LicenseContent content)
throws LicenseContentException {
//1. 首先调用父类的validate方法
super.validate(content);
//2. 然后校验自定义的License参数
//License中可被允许的参数信息
LicenseCheckModel expectedCheckModel = (LicenseCheckModel) content.getExtra();
if (expectedCheckModel != null) {
//当前服务器真实的参数信息
LicenseCheckModel serverCheckModel = getServerInfos();
if (serverCheckModel != null) {
//校验IP地址
if (!checkIpAddress(expectedCheckModel.getIpAddress(), serverCheckModel.getIpAddress())) {
throw new LicenseContentException("当前服务器的IP没在授权范围内");
}
//校验Mac地址
if (!checkIpAddress(expectedCheckModel.getMacAddress(), serverCheckModel.getMacAddress())) {
throw new LicenseContentException("当前服务器的Mac地址没在授权范围内");
}
//校验主板序列号
if (!checkSerial(expectedCheckModel.getMainBoardSerial(), serverCheckModel.getMainBoardSerial())) {
throw new LicenseContentException("当前服务器的主板序列号没在授权范围内");
}
//校验CPU序列号
if (!checkSerial(expectedCheckModel.getCpuSerial(), serverCheckModel.getCpuSerial())) {
throw new LicenseContentException("当前服务器的CPU序列号没在授权范围内");
}
} else {
throw new LicenseContentException("不能获取服务器硬件信息");
}
}
}
/**
* @title load
* @description 重写XMLDecoder解析XML
*/
private Object load(String encoded) {
BufferedInputStream inputStream = null;
XMLDecoder decoder = null;
try {
inputStream = new BufferedInputStream(new ByteArrayInputStream(encoded.getBytes(XML_CHARSET)));
decoder = new XMLDecoder(new BufferedInputStream(inputStream, DEFAULT_BUFSIZE), null, null);
return decoder.readObject();
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
} finally {
try {
if (decoder != null) {
decoder.close();
}
if (inputStream != null) {
inputStream.close();
}
} catch (Exception e) {
logger.error("XMLDecoder解析XML失败", e);
}
}
return null;
}
/**
* @title getServerInfos
* @description 获取当前服务器需要额外校验的License参数
*/
private LicenseCheckModel getServerInfos() {
//操作系统类型
String osName = System.getProperty("os.name").toLowerCase();
AbstractServerInfos abstractServerInfos = null;
//根据不同操作系统类型选择不同的数据获取方法
if (osName.startsWith("windows")) {
abstractServerInfos = new WindowsServerInfos();
} else if (osName.startsWith("linux")) {
abstractServerInfos = new LinuxServerInfos();
} else if (osName.startsWith("mac os")) {
return null;
} else {//其他服务器类型
abstractServerInfos = new LinuxServerInfos();
}
return abstractServerInfos.getServerInfos();
}
/**
* @title checkIpAddress
* @description 校验当前服务器的IP/Mac地址是否在可被允许的IP范围内<br/>
* 如果存在IP在可被允许的IP/Mac地址范围内，则返回true
*/
private boolean checkIpAddress(List<String> expectedList, List<String> serverList) {
if (expectedList != null && expectedList.size() > 0) {
if (serverList != null && serverList.size() > 0) {
for (String expected : expectedList) {
if (serverList.contains(expected.trim())) {
return true;
}
}
}
return false;
} else {
return true;
}
}
/**
* @title checkSerial
* @description 校验当前服务器硬件（主板、CPU等）序列号是否在可允许范围内
*/
private boolean checkSerial(String expectedSerial, String serverSerial) {
if (StringUtils.isNotBlank(expectedSerial)) {
if (StringUtils.isNotBlank(serverSerial)) {
if (expectedSerial.equals(serverSerial)) {
return true;
}
}
return false;
} else {
return true;
}
}
}
5、实现证书管理器LicenseManager生成器，这里我们通过双检锁来安全输出单例
import com.example.licenseclient.custom.CustomLicenseManager;
import de.schlichtherle.license.LicenseManager;
import de.schlichtherle.license.LicenseParam;
public class LicenseManagerHolder {
private static volatile LicenseManager LICENSE_MANAGER;
public static LicenseManager getInstance(LicenseParam param){
if(LICENSE_MANAGER == null){
synchronized (LicenseManagerHolder.class){
if(LICENSE_MANAGER == null){
LICENSE_MANAGER = new CustomLicenseManager(param);
}
}
}
return LICENSE_MANAGER;
}
}
6、实现密钥参数扩展类CustomKeyStoreParam，用于声明密钥、证书位置在指定路径，而非项目中
import de.schlichtherle.license.AbstractKeyStoreParam;
import java.io.*;
/**
* @author benjamin5
* @Description 自定义KeyStoreParam，用于将公私钥存储文件存放到其他磁盘位置而不是项目中
* @createTime 2024/10/31
*/
public class CustomKeyStoreParam extends AbstractKeyStoreParam {
/**
* 公钥/私钥在磁盘上的存储路径
*/
private String storePath;
private String alias;
private String storePwd;
private String keyPwd;
public CustomKeyStoreParam(Class clazz, String resource,String alias,String storePwd,String keyPwd) {
super(clazz, resource);
this.storePath = resource;
this.alias = alias;
this.storePwd = storePwd;
this.keyPwd = keyPwd;
}
@Override
public String getAlias() {
return alias;
}
@Override
public String getStorePwd() {
return storePwd;
}
@Override
public String getKeyPwd() {
return keyPwd;
}
/**
* 复写de.schlichtherle.license.AbstractKeyStoreParam的getStream()方法
* 用于将公私钥存储文件存放到其他磁盘位置而不是项目中
*/
@Override
public InputStream getStream() throws IOException {
final InputStream in = new FileInputStream(new File(storePath));
if (null == in){
throw new FileNotFoundException(storePath);
}
return in;
}
}
7、实现证书安装和校验类LicenseVerify
import com.example.licenseclient.custom.CustomKeyStoreParam;
import de.schlichtherle.license.*;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import java.io.File;
import java.text.DateFormat;
import java.text.MessageFormat;
import java.text.SimpleDateFormat;
import java.util.prefs.Preferences;
/**
* @author benjamin5
* @Description License校验类
* @createTime 2024/10/31
*/
public class LicenseVerify {
private static Logger logger = LogManager.getLogger(LicenseVerify.class);
/**
* @title install
* @description 安装License证书
*/
public synchronized LicenseContent install(LicenseVerifyParam param){
LicenseContent result = null;
DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//1. 安装证书
try{
LicenseManager licenseManager = LicenseManagerHolder.getInstance(initLicenseParam(param));
licenseManager.uninstall();
result = licenseManager.install(new File(param.getLicensePath()));
logger.info(MessageFormat.format("证书安装成功，证书有效期：{0} - {1}",format.format(result.getNotBefore()),format.format(result.getNotAfter())));
}catch (Exception e){
logger.error("证书安装失败！",e);
}
return result;
}
/**
* @title verify
* @description 校验License证书
*/
public boolean verify(){
LicenseManager licenseManager = LicenseManagerHolder.getInstance(null);
DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//2. 校验证书
try {
LicenseContent licenseContent = licenseManager.verify();
System.out.println(MessageFormat.format("证书校验通过，证书有效期：{0} - {1}",format.format(licenseContent.getNotBefore()),format.format(licenseContent.getNotAfter())));
return true;
}catch (Exception e){
logger.error("证书校验失败！",e);
return false;
}
}
/**
* @title initLicenseParam
* @description 初始化证书生成参数
*/
private LicenseParam initLicenseParam(LicenseVerifyParam param){
Preferences preferences = Preferences.userNodeForPackage(LicenseVerify.class);
CipherParam cipherParam = new DefaultCipherParam(param.getStorePass());
KeyStoreParam publicStoreParam = new CustomKeyStoreParam(LicenseVerify.class
,param.getPublicKeysStorePath()
,param.getPublicAlias()
,param.getStorePass()
,null);
return new DefaultLicenseParam(param.getSubject()
,preferences
,publicStoreParam
,cipherParam);
}
}
8、然后在项目启动时安装证书，通过ApplicationListener实现项目启动触发
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.stereotype.Component;
/**
* @author benjamin5
* @Description 在项目启动时安装证书
* @createTime 2024/10/31
*/
@Component
public class LicenseCheckListener implements ApplicationListener<ContextRefreshedEvent> {
private static Logger logger = LogManager.getLogger(LicenseCheckListener.class);
/**
* 证书subject
*/
@Value("${license.subject}")
private String subject;
/**
* 公钥别称
*/
@Value("${license.publicAlias}")
private String publicAlias;
/**
* 访问公钥库的密码
*/
@Value("${license.storePass}")
private String storePass;
/**
* 证书生成路径
*/
@Value("${license.licensePath}")
private String licensePath;
/**
* 密钥库存储路径
*/
@Value("${license.publicKeysStorePath}")
private String publicKeysStorePath;
@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
//root application context 没有parent
ApplicationContext context = event.getApplicationContext().getParent();
if (context == null) {
logger.info("++++++++ 开始安装证书 ++++++++");
LicenseVerifyParam param = new LicenseVerifyParam();
param.setSubject(subject);
param.setPublicAlias(publicAlias);
param.setStorePass(storePass);
param.setLicensePath(licensePath);
param.setPublicKeysStorePath(publicKeysStorePath);
LicenseVerify licenseVerify = new LicenseVerify();
//安装证书
licenseVerify.install(param);
logger.info("++++++++ 证书安装结束 ++++++++");
}
}
}
9、最后实现接口拦截器，在拦截器中校验证书
import com.alibaba.fastjson.JSON;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.HashMap;
import java.util.Map;
/**
* @author benjamin5
* @Description 证书校验拦截器
* @createTime 2024/10/31
*/
public class LicenseCheckInterceptor implements HandlerInterceptor {
private static Logger logger = LogManager.getLogger(LicenseCheckInterceptor.class);
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
LicenseVerify licenseVerify = new LicenseVerify();
//校验证书是否有效
boolean verifyResult = licenseVerify.verify();
if(verifyResult){
return true;
}else{
response.setCharacterEncoding("UTF-8");
response.setContentType("text/html; charset=UTF-8");
Map<String,String> result = new HashMap<>(1);
result.put("code","500");
result.put("msg","您的许可证无效或过期，请重新申请！");
response.getWriter().write(JSON.toJSONString(result));
return false;
}
}
}
10、声明拦截器
@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
/**
* 添加拦截器
*/
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(new LicenseCheckInterceptor())
.addPathPatterns("/**")
// .excludePathPatterns("/license/generateLicense","/license/getServerInfos")
;
}
}
2.3 license生成模块
1、创建springboot项目license-server，引入依赖，注意将上述的license-client项目也引入进去，生成证书需要使用client中的接口
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.example</groupId>
<artifactId>license-client</artifactId>
<version>1.0.0</version>
</dependency>
</dependencies>
2、创建证书生成参数类，LicenseCheckModel子类代码详见代码仓库
@Data
public class LicenseCreatorParam implements Serializable {
private static final long serialVersionUID = -7793154252684580872L;
/**
* 证书subject
*/
private String subject;
/**
* 密钥别称
*/
private String privateAlias;
/**
* 密钥密码（需要妥善保管，不能让使用者知道）
*/
private String keyPass;
/**
* 访问秘钥库的密码
*/
private String storePass;
/**
* 证书生成路径
*/
private String licensePath;
/**
* 密钥库存储路径
*/
private String privateKeysStorePath;
/**
* 证书生效时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
private Date issuedTime = new Date();
/**
* 证书失效时间
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
private Date expiryTime;
/**
* 用户类型
*/
private String consumerType = "user";
/**
* 用户数量
*/
private Integer consumerAmount = 1;
/**
* 描述信息
*/
private String description = "";
/**
* 额外的服务器硬件校验信息
*/
private LicenseCheckModel licenseCheckModel;
}
3、创建证书生成类LicenseCreator
import com.example.licenseclient.custom.CustomKeyStoreParam;
import com.example.licenseclient.custom.CustomLicenseManager;
import de.schlichtherle.license.*;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import javax.security.auth.x500.X500Principal;
import java.io.File;
import java.text.MessageFormat;
import java.util.prefs.Preferences;
/**
* License生成类
*
*/
public class LicenseCreator {
private static Logger logger = LogManager.getLogger(LicenseCreator.class);
/**
* CN=localhost：CN是Common Name的缩写，通常用于指定域名或IP地址
* OU=localhost：OU是Organizational Unit的缩写，表示组织单位
* O=localhost：O是Organization的缩写，表示组织名
* L=SH：L是Locality的缩写，表示城市或地区
* ST=SH：ST是State的缩写，表示州或省
* C=CN：C是Country的缩写，表示国家代码
*/
private final static X500Principal DEFAULT_HOLDER_AND_ISSUER = new X500Principal("CN=localhost, OU=localhost, O=localhost, L=SH, ST=SH, C=CN");
private LicenseCreatorParam param;
public LicenseCreator(LicenseCreatorParam param) {
this.param = param;
}
/**
* 生成License证书
* @return boolean
*/
public boolean generateLicense(){
try {
LicenseManager licenseManager = new CustomLicenseManager(initLicenseParam());
LicenseContent licenseContent = initLicenseContent();
licenseManager.store(licenseContent,new File(param.getLicensePath()));
return true;
}catch (Exception e){
logger.error(MessageFormat.format("证书生成失败：{0}",param),e);
return false;
}
}
/**
* 初始化证书生成参数
* @return de.schlichtherle.license.LicenseParam
*/
private LicenseParam initLicenseParam(){
Preferences preferences = Preferences.userNodeForPackage(LicenseCreator.class);
//设置对证书内容加密的秘钥
CipherParam cipherParam = new DefaultCipherParam(param.getStorePass());
KeyStoreParam privateStoreParam = new CustomKeyStoreParam(LicenseCreator.class
,param.getPrivateKeysStorePath()
,param.getPrivateAlias()
,param.getStorePass()
,param.getKeyPass());
LicenseParam licenseParam = new DefaultLicenseParam(param.getSubject()
,preferences
,privateStoreParam
,cipherParam);
return licenseParam;
}
/**
* 设置证书生成正文信息
* @return de.schlichtherle.license.LicenseContent
*/
private LicenseContent initLicenseContent(){
LicenseContent licenseContent = new LicenseContent();
licenseContent.setHolder(DEFAULT_HOLDER_AND_ISSUER);
licenseContent.setIssuer(DEFAULT_HOLDER_AND_ISSUER);
licenseContent.setSubject(param.getSubject());
licenseContent.setIssued(param.getIssuedTime());
licenseContent.setNotBefore(param.getIssuedTime());
licenseContent.setNotAfter(param.getExpiryTime());
licenseContent.setConsumerType(param.getConsumerType());
licenseContent.setConsumerAmount(param.getConsumerAmount());
licenseContent.setInfo(param.getDescription());
//扩展校验服务器硬件信息
licenseContent.setExtra(param.getLicenseCheckModel());
return licenseContent;
}
}
4、最后声明证书创建接口
@RestController
@RequestMapping("/license")
public class LicenseCreatorController {
/**
* 证书生成路径
*/
@Value("${license.licensePath}")
private String licensePath;
@Value("${license.privateKeysStorePath}")
private String privateKeysStorePath;
@Value("${license.keyPass}")
private String keyPass;
@Value("${license.privateAlias}")
private String privateAlias;
/**
* 生成证书
*
* @param param 生成证书需要的参数，如：{"subject":"ccx-models","privateAlias":"privateKey","keyPass":"5T7Zz5Y0dJFcqTxvzkH5LDGJJSGMzQ","storePass":"3538cef8e7","licensePath":"C:/Users/zifangsky/Desktop/license.lic","privateKeysStorePath":"C:/Users/zifangsky/Desktop/privateKeys.keystore","issuedTime":"2018-04-26 14:48:12","expiryTime":"2018-12-31 00:00:00","consumerType":"User","consumerAmount":1,"description":"这是证书描述信息","licenseCheckModel":{"ipAddress":["192.168.245.1","10.0.5.22"],"macAddress":["00-50-56-C0-00-01","50-7B-9D-F9-18-41"],"cpuSerial":"BFEBFBFF000406E3","mainBoardSerial":"L1HF65E00X9"}}
*
*/
@RequestMapping(value = "/generateLicense", produces = {MediaType.APPLICATION_JSON_UTF8_VALUE})
public Map<String, Object> generateLicense(@RequestBody(required = true) LicenseCreatorParam param) {
Map<String, Object> resultMap = new HashMap<>(2);
if (StringUtils.isBlank(param.getLicensePath())) {
param.setLicensePath(licensePath);
}
if(StringUtils.isBlank(param.getPrivateKeysStorePath())){
URL url = null;
try {
url = ResourceUtils.getURL(privateKeysStorePath);
param.setPrivateKeysStorePath(url.getPath());
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
if(StringUtils.isBlank(param.getKeyPass())){
param.setKeyPass(keyPass);
}
if(StringUtils.isBlank(param.getPrivateAlias())){
param.setPrivateAlias(privateAlias);
}
LicenseCreator licenseCreator = new LicenseCreator(param);
boolean result = licenseCreator.generateLicense();
if (result) {
resultMap.put("result", "ok");
resultMap.put("msg", param);
} else {
resultMap.put("result", "error");
resultMap.put("msg", "证书文件生成失败！");
}
return resultMap;
}
}
5、配置文件声明
server:
port: 18099
license:
# 生成证书存放位置，也可在生成接口参数中指定
licensePath: /Users/wuhanxue/Downloads/license/license.lic
# 私钥库文件位置
privateKeysStorePath: classpath:key/privateKeys.keystore
# 私钥访问密码
keyPass: wu@private2024
# 私钥别名
privateAlias: privateKey
6、我们在resources资源目录下创建key目录，并将之间生成的私钥库文件privateKeys.keystore放到该文件夹下，后续用来生成证书
7、启动该项目，然后调用证书生成接口，得到证书文件license.lic
接口参数说明：
- subject: 证书主题，可以以授权的服务名来命名，不允许使用中文
- storePass：访问密钥库密码
- licensePath：生成的证书存储位置和证书文件名
- expiryTime： 过期时间
- description：描述
- licenseCheckModel： 扩展配置类，详见代码仓库
得到的证书文件license.lic、公钥文件和密钥库密码storePass我们需要提供给客户，当然密码可以提前配置在服务中，仅提供公钥和证书文件给客户即可。
2.4 测试模块
1、新建一个spring web服务，用于测试证书校验
2、引入license-client依赖
<dependency>
<groupId>com.example</groupId>
<artifactId>license-client</artifactId>
<version>1.0.0</version>
</dependency>
3、配置文件声明
server:
port: 1888
license:
# 证书subject
subject: license-test-web
# 公钥别称
publicAlias: publicCert
# 访问公钥库的密码
storePass: wu@2024555
# 证书路径
licensePath: /Users/wuhanxue/Downloads/key/license.lic
# 公钥路径
publicKeysStorePath: /Users/wuhanxue/Downloads/key/publicCerts.keystore
4、测试接口
@RestController
public class TestController {
@GetMapping("test")
public String test(){
return "test";
}
}
5、启动类添加bean扫描路径@ComponentScan(basePackages = {"com.example.*"})
@SpringBootApplication
@ComponentScan(basePackages = {"com.example.*"})
public class LicenseTestWebApplication {
public static void main(String[] args) {
SpringApplication.run(LicenseTestWebApplication.class, args);
}
}
5、启动项目
显示证书安装成功
6、访问测试接口
成功返回信息，且有校验通过提示，说明校验成功
7、我们继续测试校验不通过的场景，重新生成license文件，并将有效期调整为1分钟后，然后等待2分钟再重启项目，注意重新生成证书后要重新启动项目，让项目重新加载证书
8、首先可以看到启动项目时已经是一分钟后了，安装实际失败了
9、调用会显示证书过期，说明正常
10、我们再模拟证书安装时是有效期内，调用时已经过了有效期的场景，将有效期调整为5分钟后，然后马上重启项目，在5分钟后调用接口，接口显示已过期，符合预期
2.5 完整代码
完整代码可见如下代码仓库：
https://gitee.com/wuhanxue/wu_study/tree/master/demo/license_demo
3.总结
如上我们演示了trueLicense生成证书及证书校验的流程，如上演示中我并未针对设备、ip等进行演示，但代码仓库中有对应代码，大家感兴趣的可以自行验证。
腾讯云面向开发者汇聚海量精品云计算使用和开发经验，营造开放的云计算技术生态圈。
更多推荐
26
0- 0
已为社区贡献12条内容
所有评论(0)