环境
- MacOS 10.14.6
- JDK1.8
源码链接：
https://github.com/zuiyu-main/springboot-demo/tree/master/springboot-license
使用keytool工具生成签名文件
生成私钥公钥
- 使用JDK自带的
keytool工具生成签名
keytool -genkeypair -keysize 1024 -validity 3650 -alias "zuiyuPrivateKey" -keypass "zuiyu_private_password_1234" -keystore "zuiyuPrivateKeys.keystore" -storepass "zuiyu_public_password_1234" -dname "CN=zuiyu,OU=zuiyu,O=zuiyu,L=BJ,ST=BJ,C=CN"
- 导出签名文件 zuiyuCertfile.cer
keytool -exportcert -alias "zuiyuPrivateKey" -keystore "zuiyuPrivateKeys.keystore" -storepass "zuiyu_public_password_1234" -file "zuiyuCertfile.cer"
- 导入签名文件
keytool -import -alias "zuiyuPublicCert" -file "zuiyuCertfile.cer" -keystore "zuiyuPublicCerts.keystore" -storepass "zuiyu_public_password_1234"
- 帮助命令（根据需要食用）
# 删除 keytool -delete -alias zuiyuPrivateKey -keystore "zuiyuPrivateKeys.keystore" -storepass "zuiyu_public_password_1234" # 查看 keytool -list -v -keystore zuiyuPrivateKeys.keystore -storepass "zuiyu_public_password_1234"
- 最后
上述命令执行完成之后，会在当前路径下生成三个文件，分别是：zuiyuPrivateKeys.keystore、zuiyuPublicCerts.keystore、zuiyuCertfile.cer。其中文件zuiyuCertfile.cer不再需要可以删除，文件zuiyuPrivateKeys.keystore用于当前的license-server项目给客户生成license文件，而文件zuiyuPublicCerts.keystore则随应用代码部署到客户服务器，用户解密license文件并校验其许可信息。
license-common
如下license-common 内容较长，全部代码都有，可直接粘贴
如下license-common 内容较长，全部代码都有，可直接粘贴
如下license-common 内容较长，全部代码都有，可直接粘贴
可直接跳转源码GitHub
https://github.com/zuiyu-main/springboot-demo/tree/master/springboot-license
- 新建一个
license-common模块 pom.xml中加入license相关依赖
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> <version>1.2.47</version> </dependency> <!-- License --> <dependency> <groupId>de.schlichtherle.truelicense</groupId> <artifactId>truelicense-core</artifactId> <version>1.33</version> </dependency> <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-lang3</artifactId> <version>3.7</version> </dependency>
- 修改pom.xml中打包插件配置
<build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <version>3.8.1</version> <configuration> <source>1.8</source> <target>1.8</target> <encoding>UTF-8</encoding> </configuration> </plugin> </plugins> </build>
- 定义一个授权文件信息类
LicenseCreatorParam
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; // 省略get set }
- 定义一个授权文件中系统信息类
LicenseCheckModel
public class LicenseCheckModel { // private static final long serialVersionUID = 8600137500316662317L; /** * 可被允许的IP地址 */ private Boolean checkIp; private List<String> ipAddress; private Boolean checkMac; /** * 可被允许的MAC地址 */ private List<String> macAddress; /** * 可被允许的CPU序列号 */ private String cpuSerial; private Boolean checkCpu; /** * 可被允许的主板序列号 */ private String mainBoardSerial; private Boolean checkMainBoard; // 省略get set }
- 定义一个校验签名文件的信息类
LicenseVerifyParam
public class LicenseVerifyParam { /** * 证书subject */ private String subject; /** * 公钥别称 */ private String publicAlias; /** * 访问公钥库的密码 */ private String storePass; /** * 证书生成路径 */ private String licensePath; /** * 密钥库存储路径 */ private String publicKeysStorePath; public LicenseVerifyParam() { } public LicenseVerifyParam(String subject, String publicAlias, String storePass, String licensePath, String publicKeysStorePath) { this.subject = subject; this.publicAlias = publicAlias; this.storePass = storePass; this.licensePath = licensePath; this.publicKeysStorePath = publicKeysStorePath; } // 省略get set }
- 定义获取客户服务器信息的抽象类
AbstractServerInfos
public abstract class AbstractServerInfos { public static Logger log = LoggerFactory.getLogger(AbstractServerInfos.class); /** * 组装需要额外校验的License参数 * * @return demo.LicenseCheckModel */ public LicenseCheckModel getServerInfos() { LicenseCheckModel result = new LicenseCheckModel(); try { result.setIpAddress(this.getIpAddress()); result.setMacAddress(this.getMacAddress()); result.setCpuSerial(this.getCPUSerial()); result.setMainBoardSerial(this.getMainBoardSerial()); } catch (Exception e) { log.error("获取服务器硬件信息失败", e); } return result; } /** * 获取IP地址 * * @return java.util.List<java.lang.String> */ protected abstract List<String> getIpAddress() throws Exception; /** * 获取Mac地址 * * @return java.util.List<java.lang.String> */ protected abstract List<String> getMacAddress() throws Exception; /** * 获取CPU序列号 * * @return java.lang.String */ protected abstract String getCPUSerial() throws Exception; /** * 获取主板序列号 * * @return java.lang.String */ protected abstract String getMainBoardSerial() throws Exception; /** * 获取当前服务器所有符合条件的InetAddress * * @return java.util.List<java.net.InetAddress> */ protected List<InetAddress> getLocalAllInetAddress() throws Exception { List<InetAddress> result = new ArrayList<>(4); // 遍历所有的网络接口 for (Enumeration networkInterfaces = NetworkInterface.getNetworkInterfaces(); networkInterfaces.hasMoreElements(); ) { NetworkInterface iface = (NetworkInterface) networkInterfaces.nextElement(); // 在所有的接口下再遍历IP for (Enumeration inetAddresses = iface.getInetAddresses(); inetAddresses.hasMoreElements(); ) { InetAddress inetAddr = (InetAddress) inetAddresses.nextElement(); //排除LoopbackAddress、SiteLocalAddress、LinkLocalAddress、MulticastAddress类型的IP地址 if (!inetAddr.isLoopbackAddress() /*&& !inetAddr.isSiteLocalAddress()*/ && !inetAddr.isLinkLocalAddress() && !inetAddr.isMulticastAddress()) { result.add(inetAddr); } } } return result; } /** * 获取某个网络接口的Mac地址 * * @param * @return void */ protected String getMacByInetAddress(InetAddress inetAddr) { try { byte[] mac = NetworkInterface.getByInetAddress(inetAddr).getHardwareAddress(); StringBuffer stringBuffer = new StringBuffer(); for (int i = 0; i < mac.length; i++) { if (i != 0) { stringBuffer.append("-"); } //将十六进制byte转化为字符串 String temp = Integer.toHexString(mac[i] & 0xff); if (temp.length() == 1) { stringBuffer.append("0" + temp); } else { stringBuffer.append(temp); } } return stringBuffer.toString().toUpperCase(); } catch (SocketException e) { log.error("获取某个网络接口的Mac地址异常", e); } return null; } }
- 定义不同系统获取系统信息的方法
LinuxServerInfos,WindowsServerInfos
- windows
public class WindowsServerInfos extends AbstractServerInfos { @Override protected List<String> getIpAddress() throws Exception { List<String> result = null; //获取所有网络接口 List<InetAddress> inetAddresses = getLocalAllInetAddress(); if (inetAddresses != null && inetAddresses.size() > 0) { result = inetAddresses.stream().map(InetAddress::getHostAddress).distinct().map(String::toLowerCase).collect(Collectors.toList()); } return result; } @Override protected List<String> getMacAddress() throws Exception { List<String> result = null; //1. 获取所有网络接口 List<InetAddress> inetAddresses = getLocalAllInetAddress(); if (inetAddresses != null && inetAddresses.size() > 0) { //2. 获取所有网络接口的Mac地址 result = inetAddresses.stream().map(this::getMacByInetAddress).distinct().collect(Collectors.toList()); } return result; } @Override protected String getCPUSerial() throws Exception { //序列号 String serialNumber = ""; //使用WMIC获取CPU序列号 Process process = Runtime.getRuntime().exec("wmic cpu get processorid"); process.getOutputStream().close(); Scanner scanner = new Scanner(process.getInputStream()); if (scanner != null && scanner.hasNext()) { scanner.next(); } if (scanner.hasNext()) { serialNumber = scanner.next().trim(); } scanner.close(); return serialNumber; } @Override protected String getMainBoardSerial() throws Exception { //序列号 String serialNumber = ""; //使用WMIC获取主板序列号 Process process = Runtime.getRuntime().exec("wmic baseboard get serialnumber"); process.getOutputStream().close(); Scanner scanner = new Scanner(process.getInputStream()); if (scanner != null && scanner.hasNext()) { scanner.next(); } if (scanner.hasNext()) { serialNumber = scanner.next().trim(); } scanner.close(); return serialNumber; } }
- linux
public class LinuxServerInfos extends AbstractServerInfos { @Override protected List<String> getIpAddress() throws Exception { List<String> result = null; //获取所有网络接口 List<InetAddress> inetAddresses = getLocalAllInetAddress(); if (inetAddresses != null && inetAddresses.size() > 0) { result = inetAddresses.stream().map(InetAddress::getHostAddress).distinct().map(String::toLowerCase).collect(Collectors.toList()); } return result; } @Override protected List<String> getMacAddress() throws Exception { List<String> result = null; //1. 获取所有网络接口 List<InetAddress> inetAddresses = getLocalAllInetAddress(); if (inetAddresses != null && inetAddresses.size() > 0) { //2. 获取所有网络接口的Mac地址 result = inetAddresses.stream().map(this::getMacByInetAddress).distinct().collect(Collectors.toList()); } return result; } @Override protected String getCPUSerial() throws Exception { //序列号 String serialNumber = ""; //使用dmidecode命令获取CPU序列号 String[] shell = {"/bin/bash", "-c", "dmidecode -t processor | grep 'ID' | awk -F ':' '{print $2}' | head -n 1"}; Process process = Runtime.getRuntime().exec(shell); process.getOutputStream().close(); BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream())); if (null == reader.readLine()) { return serialNumber; } String line = reader.readLine().trim(); if (StringUtils.isNotBlank(line)) { serialNumber = line; } reader.close(); return serialNumber; } @Override protected String getMainBoardSerial() throws Exception { //序列号 String serialNumber = ""; //使用dmidecode命令获取主板序列号 String[] shell = {"/bin/bash", "-c", "dmidecode | grep 'Serial Number' | awk -F ':' '{print $2}' | head -n 1"}; Process process = Runtime.getRuntime().exec(shell); process.getOutputStream().close(); BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream())); if (null == reader.readLine()) { return serialNumber; } String line = reader.readLine().trim(); if (StringUtils.isNotBlank(line)) { serialNumber = line; } reader.close(); return serialNumber; } }
- 增加
CustomLicenseManager，用于自定义参数信息验证
public class CustomLicenseManager extends LicenseManager { public static Logger log = LoggerFactory.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); } /** * 复写create方法 * * @return byte[] */ @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); } /** * 复写install方法，其中validate方法调用本类中的validate方法，校验IP地址、Mac地址等其他信息 * * @param * @return de.schlichtherle.license.LicenseContent */ @Override protected synchronized LicenseContent install( final byte[] key, final LicenseNotary notary) throws Exception { final GenericCertificate certificate = getPrivacyGuard().key2cert(key); notary.verify(certificate); final LicenseContent content = (LicenseContent) this.load(certificate.getEncoded()); this.validate(content); setLicenseKey(key); setCertificate(certificate); return content; } /** * 复写verify方法，调用本类中的validate方法，校验IP地址、Mac地址等其他信息 * * @param * @return de.schlichtherle.license.LicenseContent */ @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; } /** * 校验生成证书的参数信息 * * @param content 证书正文 */ 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("用户类型不能为空"); } } /** * 复写validate方法，增加IP地址、Mac地址等其他信息校验 * * @param content LicenseContent */ @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 (expectedCheckModel.getCheckIp() && !checkIpAddress(expectedCheckModel.getIpAddress(), serverCheckModel.getIpAddress())) { throw new LicenseContentException("当前服务器的IP没在授权范围内"); } //校验Mac地址 if (expectedCheckModel.getCheckMac() && !checkIpAddress(expectedCheckModel.getMacAddress(), serverCheckModel.getMacAddress())) { throw new LicenseContentException("当前服务器的Mac地址没在授权范围内"); } //校验主板序列号 if (expectedCheckModel.getCheckMainBoard() && !checkSerial(expectedCheckModel.getMainBoardSerial(), serverCheckModel.getMainBoardSerial())) { throw new LicenseContentException("当前服务器的主板序列号没在授权范围内"); } //校验CPU序列号 if (expectedCheckModel.getCheckCpu() && !checkSerial(expectedCheckModel.getCpuSerial(), serverCheckModel.getCpuSerial())) { throw new LicenseContentException("当前服务器的CPU序列号没在授权范围内"); } } else { throw new LicenseContentException("不能获取服务器硬件信息"); } } } /** * 重写XMLDecoder解析XML * * @param encoded XML类型字符串 * @return java.lang.Object */ private Object load(String encoded) { // encoded = encoded.replace("com.modules.entity.LicenseCheckModel", "com.zuiyu.client.bean.LicenseCheckModel"); 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) { log.error("XMLDecoder解析XML失败", e); } } return null; } /** * 获取当前服务器需要额外校验的License参数 * * @return demo.LicenseCheckModel */ 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 {//其他服务器类型 abstractServerInfos = new LinuxServerInfos(); } return abstractServerInfos.getServerInfos(); } /** * 校验当前服务器的IP/Mac地址是否在可被允许的IP范围内<br/> * 如果存在IP在可被允许的IP/Mac地址范围内，则返回true * * @return boolean */ 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; } } /** * 校验当前服务器硬件（主板、CPU等）序列号是否在可允许范围内 * * @param * @return boolean */ 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; } } }
- 定义
CustomKeyStoreParam，用于授权文件持久化磁盘
package com.zuiyu.common.license; import de.schlichtherle.license.AbstractKeyStoreParam; import java.io.*; /** * 自定义KeyStoreParam，用于将公私钥存储文件存放到其他磁盘位置而不是项目中 */ 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()方法<br/> * 用于将公私钥存储文件存放到其他磁盘位置而不是项目中 * * @param * @return java.io.InputStream */ @Override public InputStream getStream() throws IOException { final InputStream in = new FileInputStream(new File(storePath)); if (null == in) { throw new FileNotFoundException(storePath); } return in; } }
- 定义
LicenseManagerHolder，获取全局的唯一一个授权管理对象
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; } }
- 定义授权文件校验类
LicenseVerify
public class LicenseVerify { public static Logger log = LoggerFactory.getLogger(LicenseVerify.class); /** * 安装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())); log.info(MessageFormat.format("证书安装成功，证书有效期：{0} - {1}", format.format(result.getNotBefore()), format.format(result.getNotAfter()))); } catch (Exception e) { log.error("证书安装失败！", e); } return result; } /** * 校验License证书 * * @return boolean */ 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(licenseContent.getSubject()); log.info(MessageFormat.format("证书校验通过，证书有效期：{0} - {1}", format.format(licenseContent.getNotBefore()), format.format(licenseContent.getNotAfter()))); return true; } catch (Exception e) { log.error("证书校验失败！", e); return false; } } /** * 初始化证书生成参数 * * @param param License校验类需要的参数 * @return de.schlichtherle.license.LicenseParam */ 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); } }
- 定义授权文件生成辅助类 LicenseCreator
public class LicenseCreator { public static Logger log = LoggerFactory.getLogger(LicenseCreator.class); 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) { e.printStackTrace(); log.error(MessageFormat.format("证书生成失败：{0}", param), e.getMessage()); 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; } }
- 能看到的这的是真爱吧，毕竟全是代码干货，没有一丁点的理论啊，这谁能hold住
下面就可以进入common模块的打包了，打包结束就可以提供给server模块和client模块使用了
Maven common 模块打包
- license-common,修改
pom.xml中的打包插件为下面这种
<groupId>com.zuiyu</groupId> <artifactId>license-common</artifactId> <version>0.0.1-SNAPSHOT</version> <name>license-common</name> <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <version>3.8.1</version> <configuration> <source>1.8</source> <target>1.8</target> <encoding>UTF-8</encoding> </configuration> </plugin> </plugins> </build>
- 执行idea中的打包，也就是
mvn install
- 需要引用该模块的代码项目
pom.xml中加入以下内容
<dependency> <groupId>com.zuiyu</groupId> <artifactId>license-common</artifactId> <version>0.0.1-SNAPSHOT</version> <scope>compile</scope> </dependency>
- 完整的核心
pom.xml文件如下,只保留打包相关
- license-common
<?xml version="1.0" encoding="UTF-8"?> <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.zuiyu</groupId> <artifactId>license-common</artifactId> <version>0.0.1-SNAPSHOT</version> <name>license-common</name> <description>license-client</description> <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <version>3.8.1</version> <configuration> <source>1.8</source> <target>1.8</target> <encoding>UTF-8</encoding> </configuration> </plugin> </plugins> </build> </project>
license-server
- 引入
license-common模块
<dependency> <groupId>com.zuiyu</groupId> <artifactId>license-common</artifactId> <version>0.0.1-SNAPSHOT</version> <scope>compile</scope> </dependency>
- 创建
LicenseCreatorController用于接口调用生成授权文件
@RestController @RequestMapping("/license") public class LicenseCreatorController { public static Logger log = LoggerFactory.getLogger(LicenseCreatorController.class); /** * 证书生成路径 */ @Value("${license.licensePath}") private String licensePath; @Value("${license.privateKeysStorePath}") private String privateKeysStorePath; /** * 获取服务器硬件信息 * * @param osName 操作系统类型，如果为空则自动判断 * @return com.ccx.models.license.LicenseCheckModel */ @RequestMapping(value = "/getServerInfos", produces = {MediaType.APPLICATION_JSON_UTF8_VALUE}) public LicenseCheckModel getServerInfos(@RequestParam(value = "osName", required = false) String osName) { //操作系统类型 if (StringUtils.isBlank(osName)) { osName = System.getProperty("os.name"); } osName = osName.toLowerCase(); AbstractServerInfos abstractServerInfos = null; //根据不同操作系统类型选择不同的数据获取方法 if (osName.startsWith("windows")) { abstractServerInfos = new WindowsServerInfos(); } else if (osName.startsWith("linux")) { abstractServerInfos = new LinuxServerInfos(); } else {//其他服务器类型 abstractServerInfos = new LinuxServerInfos(); } return abstractServerInfos.getServerInfos(); } /** * 生成证书 * * @param param 生成证书需要的参数， * { * "subject": "zuiyu_demo", * "privateAlias": "zuiyuPrivateKey", * "keyPass": "zuiyu_private_password_1234", * "storePass": "zuiyu_public_password_1234", * "licensePath": "/Users/cxt/Downloads/license/license7.lic", * "privateKeysStorePath": "/Users/cxt/Downloads/license/privateKeys.keystore", * "issuedTime": "2018-07-10 00:00:01", * "expiryTime": "2022-12-31 23:59:59", * "consumerType": "User", * "consumerAmount": 1, * "description": "这是证书描述信息", * "licenseCheckModel": { * "checkIp":false, * "ipAddress": [""], * "checkMac":true, * "macAddress": ["aa-bb-cc-11"], * "checkCpu":false, * "cpuSerial": "", * "checkMainBoard":false, * "mainBoardSerial": "" * } * } * @return java.util.Map<java.lang.String, java.lang.Object> */ @RequestMapping(value = "/generateLicense", produces = {MediaType.APPLICATION_JSON_UTF8_VALUE}) public Map<String, Object> generateLicense(HttpServletRequest request, @RequestBody LicenseCreatorParam param) { Map<String, Object> resultMap = new HashMap<>(2); if (StringUtils.isBlank(param.getLicensePath())) { param.setLicensePath(licensePath); } String path = System.getProperty("user.dir") + privateKeysStorePath; param.setPrivateKeysStorePath(path); 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; } }
- 找到刚才生成的授权文件
zuiyuPrivateKeys.keystore放入项目根目录license/zuiyuPrivateKeys.keystore - 修改application.properties
# license 默认生成地址 license.licensePath=/Users/cxt/Downloads/license/license.lic # 授权签名文件相对项目的相对路径 license.privateKeysStorePath=/springboot-license/license-server/license/zuiyuPrivateKeys.keystore
- 完整的项目结构如下
├── HELP.md ├── README.md ├── license │ └── zuiyuPrivateKeys.keystore ├── pom.xml ├── src │ ├── main │ │ ├── java │ │ │ └── com │ │ │ └── zuiyu │ │ │ └── server │ │ │ ├── LicenseServerApplication.java │ │ │ └── controller │ │ │ └── LicenseCreatorController.java │ │ └── resources │ │ └── application.properties
- 请求接口生成授权
Post localhost:8080/license/generateLicense { "subject": "zuiyu_demo", "privateAlias": "zuiyuPrivateKey", "keyPass": "zuiyu_private_password_1234", "storePass": "zuiyu_public_password_1234", "licensePath": "/Users/cxt/Downloads/license/license7.lic", "privateKeysStorePath": "/Users/cxt/Downloads/license/privateKeys.keystore", "issuedTime": "2018-07-10 00:00:01", "expiryTime": "2022-12-31 23:59:59", "consumerType": "User", "consumerAmount": 1, "description": "这是证书描述信息", "licenseCheckModel": { "checkIp":false, "ipAddress": [""], "checkMac":true, "macAddress": ["aa-bb-cc-11"], "checkCpu":false, "cpuSerial": "", "checkMainBoard":false, "mainBoardSerial": "" } }
license-client
- 引入
license-common模块
<dependency> <groupId>com.zuiyu</groupId> <artifactId>license-common</artifactId> <version>0.0.1-SNAPSHOT</version> <scope>compile</scope> </dependency>
- 注册授权验证拦截器
InterceptorConfig
@Component public class InterceptorConfig implements WebMvcConfigurer { @Resource private LicenseCheckInterceptor licenseCheckInterceptor; @Override public void addInterceptors(InterceptorRegistry registry) { // 添加要拦截的url registry.addInterceptor(licenseCheckInterceptor) // 拦截的路径 .addPathPatterns("/**"); // 放行的路径 // .excludePathPatterns("/admin/login"); } }
- 定义拦截器拦截请求验证授权
LicenseCheckInterceptor
@Component public class LicenseCheckInterceptor implements HandlerInterceptor { public static Logger log = LoggerFactory.getLogger(LicenseCheckInterceptor.class); /** * 进入controller层之前拦截请求 * * @param request * @param response * @param handler * @return * @throws Exception */ @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { log.info("进入拦截器，验证证书可使用性"); LicenseVerify licenseVerify = new LicenseVerify(); //校验证书是否有效 boolean verifyResult = licenseVerify.verify(); if (verifyResult) { log.info("验证成功，证书可用"); return true; } else { log.info("验证失败，证书无效"); response.setCharacterEncoding("utf-8"); Map<String, String> result = new HashMap<>(1); result.put("result", "您的证书无效，请核查服务器是否取得授权或重新申请证书！"); response.getWriter().write(JSON.toJSONString(result)); return false; } } /** * 处理请求完成后视图渲染之前的处理操作 * * @param request * @param response * @param handler * @param modelAndView * @throws Exception */ @Override public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception { log.info("处理请求完成后视图渲染之前的处理操作"); } /** * 视图渲染之后的操作 * * @param request * @param response * @param handler * @param ex * @throws Exception */ @Override public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception { log.info("视图渲染之后的操作"); } }
- 定义启动应用时检查授权
LicenseCheckListener
@Component public class LicenseCheckListener implements ApplicationListener<ContextRefreshedEvent> { public static Logger log = LoggerFactory.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) { if (StringUtils.isNotBlank(licensePath)) { log.info("++++++++ 开始安装证书 ++++++++"); LicenseVerifyParam param = new LicenseVerifyParam(); param.setSubject(subject); param.setPublicAlias(publicAlias); param.setStorePass(storePass); param.setLicensePath(licensePath); param.setPublicKeysStorePath(System.getProperty("user.dir") + publicKeysStorePath); LicenseVerify licenseVerify = new LicenseVerify(); //安装证书 licenseVerify.install(param); log.info("++++++++ 证书安装结束 ++++++++"); } } } }
- 新建一个测试类，测试授权是否生效
LoginController
public class LoginController { public static Logger log = LoggerFactory.getLogger(LoginController.class); @GetMapping(value = "login") public Map<String, Object> test(@RequestParam(required = true) String loginName, @RequestParam(required = true) String password) { Map<String, Object> result = new HashMap<>(1); log.info(MessageFormat.format("登录名称：{0}，密码：{1}", loginName, password)); //模拟登录 log.info("模拟登录被拦截检查证书可用性"); result.put("code", 200); return result; } }
- 测试接口调用
get localhost:8082/login?loginName=111&password=111
- 完整代码结构如下
├── HELP.md ├── README.md ├── license │ └── zuiyuPublicCerts.keystore ├── pom.xml ├── src │ ├── main │ │ ├── java │ │ │ └── com │ │ │ └── zuiyu │ │ │ └── client │ │ │ ├── LicenseClientApplication.java │ │ │ ├── config │ │ │ │ └── InterceptorConfig.java │ │ │ ├── controller │ │ │ │ └── LoginController.java │ │ │ ├── interceptor │ │ │ │ └── LicenseCheckInterceptor.java │ │ │ └── license │ │ │ └── LicenseCheckListener.java │ │ └── resources │ │ └── application.properties
