License介绍

License，即版权许可证，一般用于收费软件给付费用户提供的访问许可证明。根据应用部署位置的不同，一般可以分为以下两种情况讨论：

  • 应用部署在开发者自己的云服务器上。这种情况下用户通过账号登录的形式远程访问，因此只需要在账号登录的时候校验目标账号的有效期、访问权限等信息即可。
  • 应用部署在客户的内网环境。因为这种情况开发者无法控制客户的网络环境，也不能保证应用所在服务器可以访问外网，因此通常的做法是使用服务器许可文件，在应用启动的时候加载证书，然后在登录或者其他关键操作的地方校验证书的有效性。
  • 部署到客户现场，但是客户服务器可以联网，也可以采用办法许可证书进行验证，也可以远程认证-认证服务器提供认证请求，必须走线上认证才可使用。

任何加密都有反编译、破解、跳过的手段。

license授权机制的原理

TrueLicense是一个开源的证书管理引擎。

  1. 生成密钥对，使用Keytool生成公私钥证书库。
  2. 授权者保留私钥，使用私钥对包含授权信息（如使用截止日期，MAC地址等）的license进行数字签名。

  3. 公钥给使用者（放在验证的代码中使用），用于验证license是否符合使用条件。

    springboot整合TrueLicense-生成License证书

    1、引入依赖

    1. <!-- License -->
    2. <dependency>
    3.  <groupId>de.schlichtherle.truelicense</groupId>
    4.  <artifactId>truelicense-core</artifactId>
    5.  <version>1.33</version>
    6. </dependency>

    2、新增LicenseCheckModel自定义校验参数

    ```java /**

    • @title LicenseCheckModel
    • @description 自定义需要校验的License参数
    • @author Administrator

    • @updateTime 2022/4/30 0030 18:19 */ @Data public class LicenseCheckModel implements Serializable{

      private static final long serialVersionUID = 8600137500316662317L; /**

      • 可被允许的IP地址 */ private List ipAddress;

      /**

      • 可被允许的MAC地址 */ private List macAddress;

      /**

      • 可被允许的CPU序列号 */ private String cpuSerial;

      /**

      • 可被允许的主板序列号 */ private String mainBoardSerial;

}

  1. <a name="Ls8YF"></a>
  2. ## 3、新增LicenseCreatorParam生成类参数
  3. ```java
  4. /**
  5.  * @ProjectName LicenseCreatorParam
  6.  * @author Administrator
  7.  * @version 1.0.0
  8.  * @Description License生成类需要的参数
  9.  * @createTime 2022/4/30 0030 18:19
  10.  */
  11. @Data
  12. public class LicenseCreatorParam implements Serializable {
  14.     private static final long serialVersionUID = -7793154252684580872L;
  15.     /**
  16.      * 证书subject
  17.      */
  18.     private String subject;
  20.     /**
  21.      * 密钥别称
  22.      */
  23.     private String privateAlias;
  25.     /**
  26.      * 密钥密码（需要妥善保管，不能让使用者知道）
  27.      */
  28.     private String keyPass;
  30.     /**
  31.      * 访问秘钥库的密码
  32.      */
  33.     private String storePass;
  35.     /**
  36.      * 证书生成路径
  37.      */
  38.     private String licensePath;
  40.     /**
  41.      * 密钥库存储路径
  42.      */
  43.     private String privateKeysStorePath;
  45.     /**
  46.      * 证书生效时间
  47.      */
  48.     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
  49.     private Date issuedTime = new Date();
  51.     /**
  52.      * 证书失效时间
  53.      */
  54.     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
  55.     private Date expiryTime;
  57.     /**
  58.      * 用户类型
  59.      */
  60.     private String consumerType = "user";
  62.     /**
  63.      * 用户数量
  64.      */
  65.     private Integer consumerAmount = 1;
  67.     /**
  68.      * 描述信息
  69.      */
  70.     private String description = "";
  72.     /**
  73.      * 额外的服务器硬件校验信息
  74.      */
  75.     private LicenseCheckModel licenseCheckModel;
  78. }

4、新建抽象类AbstractServerInfos

用户获取服务器的硬件信息

  1. /**
  2.  * @ProjectName AbstractServerInfos
  3.  * @author Administrator
  4.  * @version 1.0.0
  5.  * @Description 用于获取客户服务器的基本信息，如：IP、Mac地址、CPU序列号、主板序列号等
  6.  * @createTime 2022/4/30 0030 18:15
  7.  */
  8. public abstract class AbstractServerInfos {
  9.     private static Logger logger = LogManager.getLogger(AbstractServerInfos.class);
  11.     /**
  12.      * @title getServerInfos
  13.      * @description 组装需要额外校验的License参数
  14.      * @author Administrator
  15.      * @updateTime 2022/4/30 0030 18:15
  16.      */
  17.     public LicenseCheckModel getServerInfos(){
  18.         LicenseCheckModel result = new LicenseCheckModel();
  20.         try {
  21.             result.setIpAddress(this.getIpAddress());
  22.             result.setMacAddress(this.getMacAddress());
  23.             result.setCpuSerial(this.getCPUSerial());
  24.             result.setMainBoardSerial(this.getMainBoardSerial());
  25.         }catch (Exception e){
  26.             logger.error("获取服务器硬件信息失败",e);
  27.         }
  29.         return result;
  30.     }
  32.     /**
  33.      * @title getIpAddress
  34.      * @description 获取IP地址
  35.      * @author Administrator
  36.      * @updateTime 2022/4/30 0030 18:15
  37.      */
  38.     protected abstract List<String> getIpAddress() throws Exception;
  40.     /**
  41.      * @title getMacAddress
  42.      * @description 获取Mac地址
  43.      * @author Administrator
  44.      * @updateTime 2022/4/30 0030 18:16
  45.      */
  46.     protected abstract List<String> getMacAddress() throws Exception;
  48.     /**
  49.      * @title getCPUSerial
  50.      * @description 获取CPU序列号
  51.      * @author Administrator
  52.      * @updateTime 2022/4/30 0030 18:16
  53.      */
  54.     protected abstract String getCPUSerial() throws Exception;
  56.     /**
  57.      * @title getMainBoardSerial
  58.      * @description 获取主板序列号
  59.      * @author Administrator
  60.      * @updateTime 2022/4/30 0030 18:16
  61.      */
  62.     protected abstract String getMainBoardSerial() throws Exception;
  64.     /**
  65.      * @title getLocalAllInetAddress
  66.      * @description 获取当前服务器所有符合条件的InetAddress
  67.      * @author Administrator
  68.      * @updateTime 2022/4/30 0030 18:16
  69.      */
  70.     protected List<InetAddress> getLocalAllInetAddress() throws Exception {
  71.         List<InetAddress> result = new ArrayList<>(4);
  73.         // 遍历所有的网络接口
  74.         for (Enumeration networkInterfaces = NetworkInterface.getNetworkInterfaces(); networkInterfaces.hasMoreElements(); ) {
  75.             NetworkInterface iface = (NetworkInterface) networkInterfaces.nextElement();
  76.             // 在所有的接口下再遍历IP
  77.             for (Enumeration inetAddresses = iface.getInetAddresses(); inetAddresses.hasMoreElements(); ) {
  78.                 InetAddress inetAddr = (InetAddress) inetAddresses.nextElement();
  80.                 //排除LoopbackAddress、SiteLocalAddress、LinkLocalAddress、MulticastAddress类型的IP地址
  81.                 if(!inetAddr.isLoopbackAddress() /*&& !inetAddr.isSiteLocalAddress()*/
  82.                         && !inetAddr.isLinkLocalAddress() && !inetAddr.isMulticastAddress()){
  83.                     result.add(inetAddr);
  84.                 }
  85.             }
  86.         }
  88.         return result;
  89.     }
  91.     /**
  92.      * @title getMacByInetAddress
  93.      * @description 获取某个网络接口的Mac地址
  94.      * @author Administrator
  95.      * @updateTime 2022/4/30 0030 18:16
  96.      */
  97.     protected String getMacByInetAddress(InetAddress inetAddr){
  98.         try {
  99.             byte[] mac = NetworkInterface.getByInetAddress(inetAddr).getHardwareAddress();
  100.             StringBuffer stringBuffer = new StringBuffer();
  102.             for(int i=0;i<mac.length;i++){
  103.                 if(i != 0) {
  104.                     stringBuffer.append("-");
  105.                 }
  107.                 //将十六进制byte转化为字符串
  108.                 String temp = Integer.toHexString(mac[i] & 0xff);
  109.                 if(temp.length() == 1){
  110.                     stringBuffer.append("0" + temp);
  111.                 }else{
  112.                     stringBuffer.append(temp);
  113.                 }
  114.             }
  116.             return stringBuffer.toString().toUpperCase();
  117.         } catch (SocketException e) {
  118.             e.printStackTrace();
  119.         }
  121.         return null;
  122.     }
  124. }

新增LinuxServerInfos获取硬件信息

  1. /**
  2.  * @ProjectName LinuxServerInfos
  3.  * @author Administrator
  4.  * @version 1.0.0
  5.  * @Description 用于获取客户Linux服务器的基本信息
  6.  * @createTime 2022/4/30 0030 18:20
  7.  */
  8. public class LinuxServerInfos extends AbstractServerInfos {
  10.     @Override
  11.     protected List<String> getIpAddress() throws Exception {
  12.         List<String> result = null;
  14.         //获取所有网络接口
  15.         List<InetAddress> inetAddresses = getLocalAllInetAddress();
  17.         if(inetAddresses != null && inetAddresses.size() > 0){
  18.             result = inetAddresses.stream().map(InetAddress::getHostAddress).distinct().map(String::toLowerCase).collect(Collectors.toList());
  19.         }
  21.         return result;
  22.     }
  24.     @Override
  25.     protected List<String> getMacAddress() throws Exception {
  26.         List<String> result = null;
  28.         //1. 获取所有网络接口
  29.         List<InetAddress> inetAddresses = getLocalAllInetAddress();
  31.         if(inetAddresses != null && inetAddresses.size() > 0){
  32.             //2. 获取所有网络接口的Mac地址
  33.             result = inetAddresses.stream().map(this::getMacByInetAddress).distinct().collect(Collectors.toList());
  34.         }
  36.         return result;
  37.     }
  39.     @Override
  40.     protected String getCPUSerial() throws Exception {
  41.         //序列号
  42.         String serialNumber = "";
  44.         //使用dmidecode命令获取CPU序列号
  45.         String[] shell = {"/bin/bash","-c","dmidecode -t processor | grep 'ID' | awk -F ':' '{print $2}' | head -n 1"};
  46.         Process process = Runtime.getRuntime().exec(shell);
  47.         process.getOutputStream().close();
  49.         BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
  51.         String line = reader.readLine().trim();
  52.         if(StringUtils.isNotBlank(line)){
  53.             serialNumber = line;
  54.         }
  56.         reader.close();
  57.         return serialNumber;
  58.     }
  60.     @Override
  61.     protected String getMainBoardSerial() throws Exception {
  62.         //序列号
  63.         String serialNumber = "";
  65.         //使用dmidecode命令获取主板序列号
  66.         String[] shell = {"/bin/bash","-c","dmidecode | grep 'Serial Number' | awk -F ':' '{print $2}' | head -n 1"};
  67.         Process process = Runtime.getRuntime().exec(shell);
  68.         process.getOutputStream().close();
  70.         BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
  72.         String line = reader.readLine().trim();
  73.         if(StringUtils.isNotBlank(line)){
  74.             serialNumber = line;
  75.         }
  77.         reader.close();
  78.         return serialNumber;
  79.     }
  80. }

新增WindowsServer获取硬件信息

  1. /**
  2.  * @ProjectName WindowsServerInfos
  3.  * @author Administrator
  4.  * @version 1.0.0
  5.  * @Description 用于获取客户Windows服务器的基本信息
  6.  * @createTime 2022/4/30 0030 18:20
  7.  */
  8. public class WindowsServerInfos extends AbstractServerInfos {
  10.     @Override
  11.     protected List<String> getIpAddress() throws Exception {
  12.         List<String> result = null;
  14.         //获取所有网络接口
  15.         List<InetAddress> inetAddresses = getLocalAllInetAddress();
  17.         if(inetAddresses != null && inetAddresses.size() > 0){
  18.             result = inetAddresses.stream().map(InetAddress::getHostAddress).distinct().map(String::toLowerCase).collect(Collectors.toList());
  19.         }
  21.         return result;
  22.     }
  24.     @Override
  25.     protected List<String> getMacAddress() throws Exception {
  26.         List<String> result = null;
  28.         //1. 获取所有网络接口
  29.         List<InetAddress> inetAddresses = getLocalAllInetAddress();
  31.         if(inetAddresses != null && inetAddresses.size() > 0){
  32.             //2. 获取所有网络接口的Mac地址
  33.             result = inetAddresses.stream().map(this::getMacByInetAddress).distinct().collect(Collectors.toList());
  34.         }
  36.         return result;
  37.     }
  39.     @Override
  40.     protected String getCPUSerial() throws Exception {
  41.         //序列号
  42.         String serialNumber = "";
  44.         //使用WMIC获取CPU序列号
  45.         Process process = Runtime.getRuntime().exec("wmic cpu get processorid");
  46.         process.getOutputStream().close();
  47.         Scanner scanner = new Scanner(process.getInputStream());
  49.         if(scanner.hasNext()){
  50.             scanner.next();
  51.         }
  53.         if(scanner.hasNext()){
  54.             serialNumber = scanner.next().trim();
  55.         }
  57.         scanner.close();
  58.         return serialNumber;
  59.     }
  61.     @Override
  62.     protected String getMainBoardSerial() throws Exception {
  63.         //序列号
  64.         String serialNumber = "";
  66.         //使用WMIC获取主板序列号
  67.         Process process = Runtime.getRuntime().exec("wmic baseboard get serialnumber");
  68.         process.getOutputStream().close();
  69.         Scanner scanner = new Scanner(process.getInputStream());
  71.         if(scanner.hasNext()){
  72.             scanner.next();
  73.         }
  75.         if(scanner.hasNext()){
  76.             serialNumber = scanner.next().trim();
  77.         }
  79.         scanner.close();
  80.         return serialNumber;
  81.     }
  82. }

注：这里使用了模板方法模式，将不变部分的算法封装到抽象类，而基本方法的具体实现则由子类来实现。

5、新增自定义CustomKeyStoreParam

自定义KeyStoreParam类CustomKeyStoreParam类继承AbstractKeyStoreParam，实现里面一些该实现的方法。并且重写getStream()获取文件内容的方法，改成从磁盘位置读取。

  1. /**
  2.  * @ProjectName CustomKeyStoreParam
  3.  * @author Administrator
  4.  * @version 1.0.0
  5.  * @Description 自定义KeyStoreParam，用于将公私钥存储文件存放到其他磁盘位置而不是项目中
  6.  * @createTime 2022/4/30 0030 18:16
  7.  */
  8. public class CustomKeyStoreParam extends AbstractKeyStoreParam {
  10.     /**
  11.      * 公钥/私钥在磁盘上的存储路径
  12.      */
  13.     private String storePath;
  14.     private String alias;
  15.     private String storePwd;
  16.     private String keyPwd;
  18.     public CustomKeyStoreParam(Class clazz, String resource,String alias,String storePwd,String keyPwd) {
  19.         super(clazz, resource);
  20.         this.storePath = resource;
  21.         this.alias = alias;
  22.         this.storePwd = storePwd;
  23.         this.keyPwd = keyPwd;
  24.     }
  27.     @Override
  28.     public String getAlias() {
  29.         return alias;
  30.     }
  32.     @Override
  33.     public String getStorePwd() {
  34.         return storePwd;
  35.     }
  37.     @Override
  38.     public String getKeyPwd() {
  39.         return keyPwd;
  40.     }
  42.     /**
  43.      * @title getStream
  44.      * @description
  45.      * 复写de.schlichtherle.license.AbstractKeyStoreParam的getStream()方法<br/>
  46.      * 用于将公私钥存储文件存放到其他磁盘位置而不是项目中
  47.      * @author Administrator
  48.      * @updateTime 2022/4/30 0030 18:16
  49.      */
  50.     @Override
  51.     public InputStream getStream() throws IOException {
  52.         final InputStream in = new FileInputStream(new File(storePath));
  53.         if (null == in){
  54.             throw new FileNotFoundException(storePath);
  55.         }
  57.         return in;
  58.     }
  59. }

6、新增自定义LicenseManager

继承LicenseManager类，增加我们额外信息的验证(TrueLicense默认只给我们验证了时间)。大家需要根据自己的需求在validate()里面增加额外的验证。

  1. /**
  2.  * @title CustomLicenseManager
  3.  * @description 自定义LicenseManager，用于增加额外的服务器硬件信息校验
  4.  * @author Administrator
  5.  * @updateTime 2022/4/30 0030 18:17
  6.  */
  7. public class CustomLicenseManager extends LicenseManager{
  8.     private static Logger logger = LogManager.getLogger(CustomLicenseManager.class);
  10.     //XML编码
  11.     private static final String XML_CHARSET = "UTF-8";
  12.     //默认BUFSIZE
  13.     private static final int DEFAULT_BUFSIZE = 8 * 1024;
  15.     public CustomLicenseManager() {
  17.     }
  19.     public CustomLicenseManager(LicenseParam param) {
  20.         super(param);
  21.     }
  23.     /**
  24.      * @title create
  25.      * @description 复写create方法
  26.      * @author Administrator
  27.      * @updateTime 2022/4/30 0030 18:17
  28.      */
  29.     @Override
  30.     protected synchronized byte[] create(
  31.             LicenseContent content,
  32.             LicenseNotary notary)
  33.             throws Exception {
  34.         initialize(content);
  35.         this.validateCreate(content);
  36.         final GenericCertificate certificate = notary.sign(content);
  37.         return getPrivacyGuard().cert2key(certificate);
  38.     }
  40.     /**
  41.      * @title install
  42.      * @description 复写install方法，其中validate方法调用本类中的validate方法，校验IP地址、Mac地址等其他信息
  43.      * @author Administrator
  44.      * @updateTime 2022/4/30 0030 18:17
  45.      */
  46.     @Override
  47.     protected synchronized LicenseContent install(
  48.             final byte[] key,
  49.             final LicenseNotary notary)
  50.             throws Exception {
  51.         final GenericCertificate certificate = getPrivacyGuard().key2cert(key);
  53.         notary.verify(certificate);
  54.         final LicenseContent content = (LicenseContent)this.load(certificate.getEncoded());
  55.         this.validate(content);
  56.         setLicenseKey(key);
  57.         setCertificate(certificate);
  59.         return content;
  60.     }
  62.     /**
  63.      * @title verify
  64.      * @description 复写verify方法，调用本类中的validate方法，校验IP地址、Mac地址等其他信息
  65.      * @author Administrator
  66.      * @updateTime 2022/4/30 0030 18:17
  67.      */
  68.     @Override
  69.     protected synchronized LicenseContent verify(final LicenseNotary notary)
  70.             throws Exception {
  71.         GenericCertificate certificate = getCertificate();
  73.         // Load license key from preferences,
  74.         final byte[] key = getLicenseKey();
  75.         if (null == key){
  76.             throw new NoLicenseInstalledException(getLicenseParam().getSubject());
  77.         }
  79.         certificate = getPrivacyGuard().key2cert(key);
  80.         notary.verify(certificate);
  81.         final LicenseContent content = (LicenseContent)this.load(certificate.getEncoded());
  82.         this.validate(content);
  83.         setCertificate(certificate);
  85.         return content;
  86.     }
  88.     /**
  89.      * @title validateCreate
  90.      * @description 校验生成证书的参数信息
  91.      * @author Administrator
  92.      * @updateTime 2022/4/30 0030 18:18
  93.      */
  94.     protected synchronized void validateCreate(final LicenseContent content)
  95.             throws LicenseContentException {
  96.         final LicenseParam param = getLicenseParam();
  98.         final Date now = new Date();
  99.         final Date notBefore = content.getNotBefore();
  100.         final Date notAfter = content.getNotAfter();
  101.         if (null != notAfter && now.after(notAfter)){
  102.             throw new LicenseContentException("证书失效时间不能早于当前时间");
  103.         }
  104.         if (null != notBefore && null != notAfter && notAfter.before(notBefore)){
  105.             throw new LicenseContentException("证书生效时间不能晚于证书失效时间");
  106.         }
  107.         final String consumerType = content.getConsumerType();
  108.         if (null == consumerType){
  109.             throw new LicenseContentException("用户类型不能为空");
  110.         }
  111.     }
  114.     /**
  115.      * @title validate
  116.      * @description 复写validate方法，增加IP地址、Mac地址等其他信息校验
  117.      * @author Administrator
  118.      * @updateTime 2022/4/30 0030 18:18
  119.      */
  120.     @Override
  121.     protected synchronized void validate(final LicenseContent content)
  122.             throws LicenseContentException {
  123.         //1. 首先调用父类的validate方法
  124.         super.validate(content);
  126.         //2. 然后校验自定义的License参数
  127.         //License中可被允许的参数信息
  128.         LicenseCheckModel expectedCheckModel = (LicenseCheckModel) content.getExtra();
  129.         //当前服务器真实的参数信息
  130.         LicenseCheckModel serverCheckModel = getServerInfos();
  132.         if(expectedCheckModel != null && serverCheckModel != null){
  133.             //校验IP地址
  134.             if(!checkIpAddress(expectedCheckModel.getIpAddress(),serverCheckModel.getIpAddress())){
  135.                 throw new LicenseContentException("当前服务器的IP没在授权范围内");
  136.             }
  138.             //校验Mac地址
  139.             if(!checkIpAddress(expectedCheckModel.getMacAddress(),serverCheckModel.getMacAddress())){
  140.                 throw new LicenseContentException("当前服务器的Mac地址没在授权范围内");
  141.             }
  143.             //校验主板序列号
  144.             if(!checkSerial(expectedCheckModel.getMainBoardSerial(),serverCheckModel.getMainBoardSerial())){
  145.                 throw new LicenseContentException("当前服务器的主板序列号没在授权范围内");
  146.             }
  148.             //校验CPU序列号
  149.             if(!checkSerial(expectedCheckModel.getCpuSerial(),serverCheckModel.getCpuSerial())){
  150.                 throw new LicenseContentException("当前服务器的CPU序列号没在授权范围内");
  151.             }
  152.         }else{
  153.             throw new LicenseContentException("不能获取服务器硬件信息");
  154.         }
  155.     }
  158.     /**
  159.      * @title load
  160.      * @description 重写XMLDecoder解析XML
  161.      * @author Administrator
  162.      * @updateTime 2022/4/30 0030 18:18
  163.      */
  164.     private Object load(String encoded){
  165.         BufferedInputStream inputStream = null;
  166.         XMLDecoder decoder = null;
  167.         try {
  168.             inputStream = new BufferedInputStream(new ByteArrayInputStream(encoded.getBytes(XML_CHARSET)));
  170.             decoder = new XMLDecoder(new BufferedInputStream(inputStream, DEFAULT_BUFSIZE),null,null);
  172.             return decoder.readObject();
  173.         } catch (UnsupportedEncodingException e) {
  174.             e.printStackTrace();
  175.         } finally {
  176.             try {
  177.                 if(decoder != null){
  178.                     decoder.close();
  179.                 }
  180.                 if(inputStream != null){
  181.                     inputStream.close();
  182.                 }
  183.             } catch (Exception e) {
  184.                 logger.error("XMLDecoder解析XML失败",e);
  185.             }
  186.         }
  188.         return null;
  189.     }
  191.     /**
  192.      * @title getServerInfos
  193.      * @description 获取当前服务器需要额外校验的License参数
  194.      * @author Administrator
  195.      * @updateTime 2022/4/30 0030 18:18
  196.      */
  197.     private LicenseCheckModel getServerInfos(){
  198.         //操作系统类型
  199.         String osName = System.getProperty("os.name").toLowerCase();
  200.         AbstractServerInfos abstractServerInfos = null;
  202.         //根据不同操作系统类型选择不同的数据获取方法
  203.         if (osName.startsWith("windows")) {
  204.             abstractServerInfos = new WindowsServerInfos();
  205.         } else if (osName.startsWith("linux")) {
  206.             abstractServerInfos = new LinuxServerInfos();
  207.         }else{//其他服务器类型
  208.             abstractServerInfos = new LinuxServerInfos();
  209.         }
  211.         return abstractServerInfos.getServerInfos();
  212.     }
  214.     /**
  215.      * @title checkIpAddress
  216.      * @description
  217.      * 校验当前服务器的IP/Mac地址是否在可被允许的IP范围内<br/>
  218.      * 如果存在IP在可被允许的IP/Mac地址范围内，则返回true
  219.      * @author Administrator
  220.      * @updateTime 2022/4/30 0030 18:18
  221.      */
  222.     private boolean checkIpAddress(List<String> expectedList,List<String> serverList){
  223.         if(expectedList != null && expectedList.size() > 0){
  224.             if(serverList != null && serverList.size() > 0){
  225.                 for(String expected : expectedList){
  226.                     if(serverList.contains(expected.trim())){
  227.                         return true;
  228.                     }
  229.                 }
  230.             }
  232.             return false;
  233.         }else {
  234.             return true;
  235.         }
  236.     }
  238.     /**
  239.      * @title checkSerial
  240.      * @description 校验当前服务器硬件（主板、CPU等）序列号是否在可允许范围内
  241.      * @author Administrator
  242.      * @updateTime 2022/4/30 0030 18:18
  243.      */
  244.     private boolean checkSerial(String expectedSerial,String serverSerial){
  245.         if(StringUtils.isNotBlank(expectedSerial)){
  246.             if(StringUtils.isNotBlank(serverSerial)){
  247.                 if(expectedSerial.equals(serverSerial)){
  248.                     return true;
  249.                 }
  250.             }
  252.             return false;
  253.         }else{
  254.             return true;
  255.         }
  256.     }
  258. }

7、新增LicenseCreator证书生成类

  1. /**
  2.  * @ProjectName LicenseCreator
  3.  * @author Administrator
  4.  * @version 1.0.0
  5.  * @Description License生成类
  6.  * @createTime 2022/4/30 0030 18:19
  7.  */
  8. public class LicenseCreator {
  9.     private static Logger logger = LogManager.getLogger(LicenseCreator.class);
  10.     private final static X500Principal DEFAULT_HOLDER_AND_ISSUER = new X500Principal("CN=localhost, OU=localhost, O=localhost, L=SH, ST=SH, C=CN");
  11.     private LicenseCreatorParam param;
  13.     public LicenseCreator(LicenseCreatorParam param) {
  14.         this.param = param;
  15.     }
  17.     /**
  18.      * @title generateLicense
  19.      * @description 生成License证书
  20.      * @author Administrator
  21.      * @updateTime 2022/4/30 0030 18:19
  22.      */
  23.     public boolean generateLicense(){
  24.         try {
  25.             LicenseManager licenseManager = new CustomLicenseManager(initLicenseParam());
  26.             LicenseContent licenseContent = initLicenseContent();
  28.             licenseManager.store(licenseContent,new File(param.getLicensePath()));
  30.             return true;
  31.         }catch (Exception e){
  32.             logger.error(MessageFormat.format("证书生成失败：{0}",param),e);
  33.             return false;
  34.         }
  35.     }
  37.     /**
  38.      * @title initLicenseParam
  39.      * @description 初始化证书生成参数
  40.      * @author Administrator
  41.      * @updateTime 2022/4/30 0030 18:19
  42.      */
  43.     private LicenseParam initLicenseParam(){
  44.         Preferences preferences = Preferences.userNodeForPackage(LicenseCreator.class);
  46.         //设置对证书内容加密的秘钥
  47.         CipherParam cipherParam = new DefaultCipherParam(param.getStorePass());
  49.         KeyStoreParam privateStoreParam = new CustomKeyStoreParam(LicenseCreator.class
  50.                 ,param.getPrivateKeysStorePath()
  51.                 ,param.getPrivateAlias()
  52.                 ,param.getStorePass()
  53.                 ,param.getKeyPass());
  55.         LicenseParam licenseParam = new DefaultLicenseParam(param.getSubject()
  56.                 ,preferences
  57.                 ,privateStoreParam
  58.                 ,cipherParam);
  60.         return licenseParam;
  61.     }
  63.     /**
  64.      * @title initLicenseContent
  65.      * @description 设置证书生成正文信息
  66.      * @author Administrator
  67.      * @updateTime 2022/4/30 0030 18:19
  68.      */
  69.     private LicenseContent initLicenseContent(){
  70.         LicenseContent licenseContent = new LicenseContent();
  71.         licenseContent.setHolder(DEFAULT_HOLDER_AND_ISSUER);
  72.         licenseContent.setIssuer(DEFAULT_HOLDER_AND_ISSUER);
  74.         licenseContent.setSubject(param.getSubject());
  75.         licenseContent.setIssued(param.getIssuedTime());
  76.         licenseContent.setNotBefore(param.getIssuedTime());
  77.         licenseContent.setNotAfter(param.getExpiryTime());
  78.         licenseContent.setConsumerType(param.getConsumerType());
  79.         licenseContent.setConsumerAmount(param.getConsumerAmount());
  80.         licenseContent.setInfo(param.getDescription());
  82.         //扩展校验服务器硬件信息
  83.         licenseContent.setExtra(param.getLicenseCheckModel());
  85.         return licenseContent;
  86.     }
  88. }

8、新增LicenseCreatorController证书生成

这个Controller对外提供了两个RESTful接口，分别是「获取服务器硬件信息」和「生成证书」

  1. /**
  2.  * @ProjectName LicenseCreatorController
  3.  * @author Administrator
  4.  * @version 1.0.0
  5.  * @Description 于生成证书文件，不能放在给客户部署的代码里
  6.  * @createTime 2022/4/30 0030 18:13
  7.  */
  8. @RestController
  9. @RequestMapping("/license")
  10. public class LicenseCreatorController {
  12.     /**
  13.      * 证书生成路径
  14.      */
  15.     @Value("${license.licensePath}")
  16.     private String licensePath;
  18.     /**
  19.      * @title 获取服务器硬件信息
  20.      * @description @param osName 操作系统类型，如果为空则自动判断
  21.      * @author Administrator
  22.      * @updateTime 2022/4/30 0030 18:14
  23.      */
  24.     @RequestMapping(value = "/getServerInfos")
  25.     public LicenseCheckModel getServerInfos(@RequestParam(value = "osName",required = false) String osName) {
  26.         //操作系统类型
  27.         if(StringUtils.isBlank(osName)){
  28.             osName = System.getProperty("os.name");
  29.         }
  30.         osName = osName.toLowerCase();
  32.         AbstractServerInfos abstractServerInfos = null;
  34.         //根据不同操作系统类型选择不同的数据获取方法
  35.         if (osName.startsWith("windows")) {
  36.             abstractServerInfos = new WindowsServerInfos();
  37.         } else if (osName.startsWith("linux")) {
  38.             abstractServerInfos = new LinuxServerInfos();
  39.         }else{//其他服务器类型
  40.             abstractServerInfos = new LinuxServerInfos();
  41.         }
  43.         return abstractServerInfos.getServerInfos();
  44.     }
  47.     /**
  48.      * @title 生成证书
  49.      * @description
  50.      * {
  51.      *     "result": "ok",
  52.      *     "msg": {
  53.      *         "subject": "license_demo",
  54.      *         "privateAlias": "privateKey",
  55.      *         "keyPass": "private_password1234",
  56.      *         "storePass": "public_password1234",
  57.      *         "licensePath": "D:/license/license.lic",
  58.      *         "privateKeysStorePath": "D:/license/privateKeys.keystore",
  59.      *         "issuedTime": "2022-04-10 00:00:01",
  60.      *         "expiryTime": "2022-05-31 23:59:59",
  61.      *         "consumerType": "User",
  62.      *         "consumerAmount": 1,
  63.      *         "description": "这是证书描述信息",
  64.      *         "licenseCheckModel": {
  65.      *             "ipAddress": [],
  66.      *             "macAddress": [],
  67.      *             "cpuSerial": "",
  68.      *             "mainBoardSerial": ""
  69.      *         }
  70.      *     }
  71.      * }
  72.      * @author Administrator
  73.      * @updateTime 2022/4/30 0030 18:14 
  74.      */
  75.     @RequestMapping(value = "/generateLicense",produces = {MediaType.APPLICATION_JSON_UTF8_VALUE})
  76.     public Map<String,Object> generateLicense(@RequestBody(required = true) LicenseCreatorParam param) {
  77.         Map<String,Object> resultMap = new HashMap<>(2);
  79.         if(StringUtils.isBlank(param.getLicensePath())){
  80.             param.setLicensePath(licensePath);
  81.         }
  83.         LicenseCreator licenseCreator = new LicenseCreator(param);
  84.         boolean result = licenseCreator.generateLicense();
  86.         if(result){
  87.             resultMap.put("result","ok");
  88.             resultMap.put("msg",param);
  89.         }else{
  90.             resultMap.put("result","error");
  91.             resultMap.put("msg","证书文件生成失败！");
  92.         }
  94.         return resultMap;
  95.     }
  97. }

9、使用Keytool生成公私钥证书库

假如我们设置公钥库密码为：public_password1234，私钥库密码为：private_password1234，则生成命令如下：

  1. ## 1. 生成私匙库
  2. # validity：私钥的有效期多少天
  3. # alias：私钥别称
  4. # keystore: 指定私钥库文件的名称(生成在当前目录)
  5. # storepass：指定私钥库的密码(获取keystore信息所需的密码) 
  6. # keypass：指定别名条目的密码(私钥的密码) 
  7. keytool -genkeypair -keysize 1024 -validity 3650 -alias "privateKey" -keystore "privateKeys.keystore" -storepass "public_password1234" -keypass "private_password1234" -dname "CN=localhost, OU=localhost, O=localhost, L=SH, ST=SH, C=CN"
  8. ## 2. 把私匙库内的公匙导出到一个文件当中
  9. # alias：私钥别称
  10. # keystore：指定私钥库的名称(在当前目录查找)
  11. # storepass: 指定私钥库的密码
  12. # file：证书名称
  13. keytool -exportcert -alias "privateKey" -keystore "privateKeys.keystore" -storepass "public_password1234" -file "certfile.cer"
  14. ## 3. 再把这个证书文件导入到公匙库
  15. # alias：公钥别称
  16. # file：证书名称
  17. # keystore：公钥文件名称
  18. # storepass：指定私钥库的密码
  19. keytool -import -alias "publicCert" -file "certfile.cer" -keystore "publicCerts.keystore" -storepass "public_password1234"

述命令执行完成之后，会在当前路径下生成三个文件，分别是：privateKeys.keystore、publicCerts.keystore、certfile.cer。其中文件certfile.cer不再需要可以删除，文件privateKeys.keystore用于当前的 qingfeng-server 项目给客户生成license文件，而文件publicCerts.keystore则随应用代码部署到客户qingfeng-client服务器，用户解密license文件并校验其许可信息。
image.png

10、生成license证书

运行项目，项目启动后，通过postmain进行测试：

获取服务器硬件信息

请求地址：http://localhost:8000/license/getServerInfos
image.png

生成license证书

访问地址：http://localhost:8000/license/generateLicense
image.png
请求时需要在Header中添加一个 Content-Type ，其值为：application/json;charset=UTF-8。参数示例如下

  1. {
  2.     "subject": "license_demo",
  3.     "privateAlias": "privateKey",
  4.     "keyPass": "private_password1234",
  5.     "storePass": "public_password1234",
  6.     "licensePath": "D:/license/license.lic",
  7.     "privateKeysStorePath": "D:/license/privateKeys.keystore",
  8.     "issuedTime": "2022-04-10 00:00:01",
  9.     "expiryTime": "2022-05-31 23:59:59",
  10.     "consumerType": "User",
  11.     "consumerAmount": 1,
  12.     "description": "这是证书描述信息",
  13.     "licenseCheckModel": {
  14.         "ipAddress": [],
  15.         "macAddress": [],
  16.         "cpuSerial": "",
  17.         "mainBoardSerial": ""
  18.     }
  19. }

如果请求成功，那么最后会在 licensePath 参数设置的路径生成一个 license.lic 的文件，这个文件就是给客户部署代码的服务器许可文件。
image.png

新建Test测试类生成证书

  1. /**
  2.  * @author Administrator
  3.  * @version 1.0.0
  4.  * @ProjectName qingfeng-license
  5.  * @Description TODO
  6.  * @createTime 2022年04月30日 21:27:00
  7.  */
  8. @SpringBootTest
  9. public class LicenseTest {
  11.     /**
  12.      * {
  13.      *     "subject": "license_demo",
  14.      *     "privateAlias": "privateKey",
  15.      *     "keyPass": "private_password1234",
  16.      *     "storePass": "public_password1234",
  17.      *     "licensePath": "D:/license/license.lic",
  18.      *     "privateKeysStorePath": "D:/license/privateKeys.keystore",
  19.      *     "issuedTime": "2022-04-10 00:00:01",
  20.      *     "expiryTime": "2022-05-31 23:59:59",
  21.      *     "consumerType": "User",
  22.      *     "consumerAmount": 1,
  23.      *     "description": "这是证书描述信息",
  24.      *     "licenseCheckModel": {
  25.      *         "ipAddress": [],
  26.      *         "macAddress": [],
  27.      *         "cpuSerial": "",
  28.      *         "mainBoardSerial": ""
  29.      *        }
  30.      * }
  31.      */
  32.     @Test
  33.     public void licenseCreate() {
  34.         // 生成license需要的一些参数
  35.         LicenseCreatorParam param = new LicenseCreatorParam();
  36.         param.setSubject("license_demo");
  37.         param.setPrivateAlias("privateKey");
  38.         param.setKeyPass("private_password1234");
  39.         param.setStorePass("public_password1234");
  40.         param.setLicensePath("D:/license/license.lic");
  41.         param.setPrivateKeysStorePath("D:/license/privateKeys.keystore");
  42.         Calendar issueCalendar = Calendar.getInstance();
  43.         param.setIssuedTime(issueCalendar.getTime());
  44.         Calendar expiryCalendar = Calendar.getInstance();
  45.         expiryCalendar.set(2022, Calendar.JUNE, 31, 23, 59, 59);
  46.         param.setExpiryTime(expiryCalendar.getTime());
  47.         param.setConsumerType("user");
  48.         param.setConsumerAmount(1);
  49.         param.setDescription("这是证书描述信息");
  50.         //自定义需要校验的License参数
  51.         LicenseCheckModel licenseCheckModel = new LicenseCheckModel();
  52.         licenseCheckModel.setCpuSerial("");
  53.         licenseCheckModel.setMainBoardSerial("");
  54.         licenseCheckModel.setIpAddress(new ArrayList<>());
  55.         licenseCheckModel.setMacAddress(new ArrayList<>());
  56.         LicenseCreator licenseCreator = new LicenseCreator(param);
  57.         param.setLicenseCheckModel(licenseCheckModel);
  58.         // 生成license
  59.         licenseCreator.generateLicense();
  60.     }
  62. }

springboot整合TrueLicense-验证License证书

1、新增License校验类参数

  1. /**
  2.  * @ProjectName LicenseVerifyParam
  3.  * @author Administrator
  4.  * @version 1.0.0
  5.  * @Description License校验类需要的参数
  6.  * @createTime 2022/4/30 0030 18:29
  7.  */
  8. @Data
  9. public class LicenseVerifyParam {
  11.     /**
  12.      * 证书subject
  13.      */
  14.     private String subject;
  16.     /**
  17.      * 公钥别称
  18.      */
  19.     private String publicAlias;
  21.     /**
  22.      * 访问公钥库的密码
  23.      */
  24.     private String storePass;
  26.     /**
  27.      * 证书生成路径
  28.      */
  29.     private String licensePath;
  31.     /**
  32.      * 密钥库存储路径
  33.      */
  34.     private String publicKeysStorePath;
  36.     public LicenseVerifyParam() {
  38.     }
  40.     public LicenseVerifyParam(String subject, String publicAlias, String storePass, String licensePath, String publicKeysStorePath) {
  41.         this.subject = subject;
  42.         this.publicAlias = publicAlias;
  43.         this.storePass = storePass;
  44.         this.licensePath = licensePath;
  45.         this.publicKeysStorePath = publicKeysStorePath;
  46.     }
  48. }

2、新增LicenseVerify校验类

  1. /**
  2.  * @ProjectName LicenseVerify
  3.  * @author Administrator
  4.  * @version 1.0.0
  5.  * @Description License校验类
  6.  * @createTime 2022/4/30 0030 18:28
  7.  */
  8. public class LicenseVerify {
  9.     private static Logger logger = LogManager.getLogger(LicenseVerify.class);
  11.     /**
  12.      * @title install
  13.      * @description 安装License证书
  14.      * @author Administrator
  15.      * @updateTime 2022/4/30 0030 18:29
  16.      */
  17.     public synchronized LicenseContent install(LicenseVerifyParam param){
  18.         LicenseContent result = null;
  19.         DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  21.         //1. 安装证书
  22.         try{
  23.             LicenseManager licenseManager = LicenseManagerHolder.getInstance(initLicenseParam(param));
  24.             licenseManager.uninstall();
  26.             result = licenseManager.install(new File(param.getLicensePath()));
  27.             logger.info(MessageFormat.format("证书安装成功，证书有效期：{0} - {1}",format.format(result.getNotBefore()),format.format(result.getNotAfter())));
  28.         }catch (Exception e){
  29.             logger.error("证书安装失败！",e);
  30.         }
  32.         return result;
  33.     }
  35.     /**
  36.      * @title verify
  37.      * @description 校验License证书
  38.      * @author Administrator
  39.      * @updateTime 2022/4/30 0030 18:29
  40.      */
  41.     public boolean verify(){
  42.         LicenseManager licenseManager = LicenseManagerHolder.getInstance(null);
  43.         DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  45.         //2. 校验证书
  46.         try {
  47.             LicenseContent licenseContent = licenseManager.verify();
  48. //            System.out.println(licenseContent.getSubject());
  50.             logger.info(MessageFormat.format("证书校验通过，证书有效期：{0} - {1}",format.format(licenseContent.getNotBefore()),format.format(licenseContent.getNotAfter())));
  51.             return true;
  52.         }catch (Exception e){
  53.             logger.error("证书校验失败！",e);
  54.             return false;
  55.         }
  56.     }
  58.     /**
  59.      * @title initLicenseParam
  60.      * @description 初始化证书生成参数
  61.      * @author Administrator
  62.      * @updateTime 2022/4/30 0030 18:29
  63.      */
  64.     private LicenseParam initLicenseParam(LicenseVerifyParam param){
  65.         Preferences preferences = Preferences.userNodeForPackage(LicenseVerify.class);
  67.         CipherParam cipherParam = new DefaultCipherParam(param.getStorePass());
  69.         KeyStoreParam publicStoreParam = new CustomKeyStoreParam(LicenseVerify.class
  70.                 ,param.getPublicKeysStorePath()
  71.                 ,param.getPublicAlias()
  72.                 ,param.getStorePass()
  73.                 ,null);
  75.         return new DefaultLicenseParam(param.getSubject()
  76.                 ,preferences
  77.                 ,publicStoreParam
  78.                 ,cipherParam);
  79.     }
  81. }

3、新增LicenseCheckListener监听器

用于在项目启动的时候安装License证书

  1. /**
  2.  * @ProjectName LicenseCheckListener
  3.  * @author Administrator
  4.  * @version 1.0.0
  5.  * @Description 在项目启动时安装证书
  6.  * @createTime 2022/4/30 0030 18:28
  7.  */
  8. @Component
  9. public class LicenseCheckListener implements ApplicationListener<ContextRefreshedEvent> {
  10.     private static Logger logger = LogManager.getLogger(LicenseCheckListener.class);
  12.     /**
  13.      * 证书subject
  14.      */
  15.     @Value("${license.subject}")
  16.     private String subject;
  18.     /**
  19.      * 公钥别称
  20.      */
  21.     @Value("${license.publicAlias}")
  22.     private String publicAlias;
  24.     /**
  25.      * 访问公钥库的密码
  26.      */
  27.     @Value("${license.storePass}")
  28.     private String storePass;
  30.     /**
  31.      * 证书生成路径
  32.      */
  33.     @Value("${license.licensePath}")
  34.     private String licensePath;
  36.     /**
  37.      * 密钥库存储路径
  38.      */
  39.     @Value("${license.publicKeysStorePath}")
  40.     private String publicKeysStorePath;
  42.     @Override
  43.     public void onApplicationEvent(ContextRefreshedEvent event) {
  44.         //root application context 没有parent
  45.         ApplicationContext context = event.getApplicationContext().getParent();
  46.         if(context == null){
  47.             if(StringUtils.isNotBlank(licensePath)){
  48.                 logger.info("++++++++ 开始安装证书 ++++++++");
  50.                 LicenseVerifyParam param = new LicenseVerifyParam();
  51.                 param.setSubject(subject);
  52.                 param.setPublicAlias(publicAlias);
  53.                 param.setStorePass(storePass);
  54.                 param.setLicensePath(licensePath);
  55.                 param.setPublicKeysStorePath(publicKeysStorePath);
  57.                 LicenseVerify licenseVerify = new LicenseVerify();
  58.                 //安装证书
  59.                 licenseVerify.install(param);
  61.                 logger.info("++++++++ 证书安装结束 ++++++++");
  62.             }
  63.         }
  64.     }
  65. }

上面代码使用参数信息如下所示：

  1. #License相关配置
  2. license.subject=license_demo
  3. license.publicAlias=publicCert
  4. license.storePass=public_password1234
  5. license.licensePath=D:/license/license.lic
  6. license.publicKeysStorePath=D:/license/publicCerts.keystore

image.png

4、新增拦截器-请求验证证书

  1. /**
  2.  * @ProjectName LicenseCheckInterceptor
  3.  * @author Administrator
  4.  * @version 1.0.0
  5.  * @Description LicenseCheckInterceptor
  6.  * @createTime 2022/4/30 0030 18:27
  7.  */
  8. public class LicenseCheckInterceptor implements HandlerInterceptor {
  9.     private static Logger logger = LogManager.getLogger(LicenseCheckInterceptor.class);
  11.     @Override
  12.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
  13.         LicenseVerify licenseVerify = new LicenseVerify();
  15.         //校验证书是否有效
  16.         boolean verifyResult = licenseVerify.verify();
  18.         if(verifyResult){
  19.             return true;
  20.         }else{
  21.             response.setCharacterEncoding("utf-8");
  22.             Map<String,String> result = new HashMap<>(1);
  23.             result.put("result","您的证书无效，请核查服务器是否取得授权或重新申请证书！");
  25.             response.getWriter().write(JSON.toJSONString(result));
  27.             return false;
  28.         }
  29.     }
  31. }

5、新建WebMvcConfig注册拦截器

  1. /**
  2.  * @ProjectName WebMvcConfig
  3.  * @author Administrator
  4.  * @version 1.0.0
  5.  * @Description 注册拦截器
  6.  * @createTime 2022/4/30 0030 21:11
  7.  */
  8. @Configuration
  9. public class WebMvcConfig implements WebMvcConfigurer {
  11.     /**
  12.      * 添加拦截器
  13.      */
  14.     @Override
  15.     public void addInterceptors(InterceptorRegistry registry) {
  16.         registry.addInterceptor(new LicenseCheckInterceptor()).addPathPatterns("/check");
  17.     }
  18. }

其他辅助列参考服务端
image.png

6、启动项目测试

image.png