TrueLicense实现license验证

骑猪看日落 2021-10-19 05:52 568阅读 0赞

TrueLicense是一个开源的证书管理引擎，可以用于license的生成和有效性的验证。

# 一 使用keytool生产密钥对 #

keytool是jdk里面自带的命令。我们直接用keytool命令来生成密钥对。需要执行的命令如下(命令里面的参数大家根据情况不同做相应的调整)

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

在任意目录下执行完上述三个命令之后。我们会在当前目录下面得到三个文件：privateKeys.keystore、publicCerts.keystore、certfile.cer。

*  privateKeys.keystore：私钥，这个我们自己留着，不能泄露给别人。
 *  publicCerts.keystore：公钥，这个给客人用的。在我们程序里面就是用他来解析license文件里面的信息的。
 *  certfile.cer：这个文件没啥用，可以删掉。

# 二 TrueLicense的使用 #

我们已经生成好了密钥对(私钥、公钥)。接下来就是生成license文件，已经严重license是否有效了。license文件里面保存了我们需要验证的一些信息。这里没问使用TrueLicense来实现license的创建和验证。

> 项目中添加TrueLicense依赖

<dependency>
                <groupId>de.schlichtherle.truelicense</groupId>
                <artifactId>truelicense-core</artifactId>
                <version>1.33</version>
                <scope>provided</scope>
            </dependency>

# 2.1 代码封装 #

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

/**
     * 自定义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;
        }
    
        /**
         * AbstractKeyStoreParam里面的getStream()方法默认文件是存储的项目中。
         * 用于将公私钥存储文件存放到其他磁盘位置而不是项目中
         */
        @Override
        public InputStream getStream() throws IOException {
            return new FileInputStream(new File(storePath));
        }
    }

自定义一个LicenseExtraModel类。我们可以在这里添加一些额外的验证信息(TrueLicense默认只帮我们验证了时间)，比如我们可以验证客户的机器码啥的。大家可以根据具体的需求添加具体的字段。

/**
     * 自定义需要校验的License参数，可以增加一些额外需要校验的参数，比如项目信息，ip地址信息等等，待完善
     */
    public class LicenseExtraModel {
    
        // 这里可以添加一些往外的自定义信息，比如我们可以增加项目验证，客户电脑sn码的验证等等
    
    }

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

/**
     * 自定义LicenseManager，用于增加额外的信息校验(除了LicenseManager的校验，我们还可以在这个类里面添加额外的校验信息)
     */
    public class CustomLicenseManager extends LicenseManager {
    
        private static Logger logger = LogManager.getLogger(CustomLicenseManager.class);
    
        public CustomLicenseManager(LicenseParam param) {
            super(param);
        }
    
        /**
         * 复写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);
        }
    
        /**
         * 复写install方法，其中validate方法调用本类中的validate方法，校验IP地址、Mac地址等其他信息
         */
        @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地址等其他信息
         */
        @Override
        protected synchronized LicenseContent verify(final LicenseNotary notary) throws Exception {
    
            // Load license key from preferences,
            final byte[] key = getLicenseKey();
            if (null == key) {
                throw new NoLicenseInstalledException(getLicenseParam().getSubject());
            }
    
            GenericCertificate certificate = getPrivacyGuard().key2cert(key);
            notary.verify(certificate);
            final LicenseContent content = (LicenseContent) this.load(certificate.getEncoded());
            this.validate(content);
            setCertificate(certificate);
    
            return 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方法，用于增加我们额外的校验信息
         */
        @Override
        protected synchronized void validate(final LicenseContent content) throws LicenseContentException {
            //1. 首先调用父类的validate方法
            super.validate(content);
            //2. 然后校验自定义的License参数，去校验我们的license信息
            LicenseExtraModel expectedCheckModel = (LicenseExtraModel) content.getExtra();
            // 做我们自定义的校验
        }
    
    
        /**
         * 重写XMLDecoder解析XML
         */
        private Object load(String encoded) {
            BufferedInputStream inputStream = null;
            XMLDecoder decoder = null;
            try {
                inputStream = new BufferedInputStream(new ByteArrayInputStream(encoded.getBytes(XMLConstants.XML_CHARSET)));
                decoder = new XMLDecoder(new BufferedInputStream(inputStream, XMLConstants.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;
        }
    
    }

# 2.2 license生成 #

生成证书需要的参数类。LicenseCreatorParam

/**
     * License生成类需要的参数
     */
    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;
    
        /**
         * 证书生效时间
         */
        private Date issuedTime = new Date();
    
        /**
         * 证书失效时间
         */
        private Date expiryTime;
    
        /**
         * 用户类型
         */
        private String consumerType = "user";
    
        /**
         * 用户数量
         */
        private Integer consumerAmount = 1;
    
        /**
         * 描述信息
         */
        private String description = "";
    
        /**
         * 额外的服务器硬件校验信息
         */
        private LicenseExtraModel licenseExtraModel;
    
        public String getSubject() {
            return subject;
        }
    
        public void setSubject(String subject) {
            this.subject = subject;
        }
    
        public String getPrivateAlias() {
            return privateAlias;
        }
    
        public void setPrivateAlias(String privateAlias) {
            this.privateAlias = privateAlias;
        }
    
        public String getKeyPass() {
            return keyPass;
        }
    
        public void setKeyPass(String keyPass) {
            this.keyPass = keyPass;
        }
    
        public String getStorePass() {
            return storePass;
        }
    
        public void setStorePass(String storePass) {
            this.storePass = storePass;
        }
    
        public String getLicensePath() {
            return licensePath;
        }
    
        public void setLicensePath(String licensePath) {
            this.licensePath = licensePath;
        }
    
        public String getPrivateKeysStorePath() {
            return privateKeysStorePath;
        }
    
        public void setPrivateKeysStorePath(String privateKeysStorePath) {
            this.privateKeysStorePath = privateKeysStorePath;
        }
    
        public Date getIssuedTime() {
            return issuedTime;
        }
    
        public void setIssuedTime(Date issuedTime) {
            this.issuedTime = issuedTime;
        }
    
        public Date getExpiryTime() {
            return expiryTime;
        }
    
        public void setExpiryTime(Date expiryTime) {
            this.expiryTime = expiryTime;
        }
    
        public String getConsumerType() {
            return consumerType;
        }
    
        public void setConsumerType(String consumerType) {
            this.consumerType = consumerType;
        }
    
        public Integer getConsumerAmount() {
            return consumerAmount;
        }
    
        public void setConsumerAmount(Integer consumerAmount) {
            this.consumerAmount = consumerAmount;
        }
    
        public String getDescription() {
            return description;
        }
    
        public void setDescription(String description) {
            this.description = description;
        }
    
        public LicenseExtraModel getLicenseExtraModel() {
            return licenseExtraModel;
        }
    
        public void setLicenseExtraModel(LicenseExtraModel licenseExtraModel) {
            this.licenseExtraModel = licenseExtraModel;
        }
        
    }

生成license的逻辑实现。

/**
     * License生成类 -- 用于license生成
     */
    public class LicenseCreator {
    
        private final static X500Principal DEFAULT_HOLDER_AND_ISSUER = new X500Principal("CN=localhost, OU=localhost, O=localhost, L=SH, ST=SH, C=CN");
    
        private static Logger logger = LogManager.getLogger(LicenseCreator.class);
    
        private LicenseCreatorParam param;
    
        public LicenseCreator(LicenseCreatorParam param) {
            this.param = param;
        }
    
        /**
         * 生成License证书
         */
        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;
            }
        }
    
        /**
         * 初始化证书生成参数
         */
        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());
    
            return new DefaultLicenseParam(param.getSubject()
                    , preferences
                    , privateStoreParam
                    , cipherParam);
        }
    
        /**
         * 设置证书生成正文信息
         */
        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());
    
            //扩展校验，这里可以自定义一些额外的校验信息(也可以用json字符串保存)
            if (param.getLicenseExtraModel() != null) {
                licenseContent.setExtra(param.getLicenseExtraModel());
            }
    
            return licenseContent;
        }
    
    }

这里我们简单一点直接测试代码来生成证书。最后会在我们的指定目录下面生成一个license.lic文件。

@Test
        public void licenseCreate() {
            // 生成license需要的一些参数
            LicenseCreatorParam param = new LicenseCreatorParam();
            param.setSubject("ioserver");
            param.setPrivateAlias("privateKey");
            param.setKeyPass("a123456");
            param.setStorePass("a123456");
            param.setLicensePath("D:\\licenseTest\\license.lic");
            param.setPrivateKeysStorePath("D:\\licenseTest\\privateKeys.keystore");
            Calendar issueCalendar = Calendar.getInstance();
            param.setIssuedTime(issueCalendar.getTime());
            Calendar expiryCalendar = Calendar.getInstance();
            expiryCalendar.set(2020, Calendar.DECEMBER, 31, 23, 59, 59);
            param.setExpiryTime(expiryCalendar.getTime());
            param.setConsumerType("user");
            param.setConsumerAmount(1);
            param.setDescription("测试");
            LicenseCreator licenseCreator = new LicenseCreator(param);
            // 生成license
            licenseCreator.generateLicense();
        }

# 2.3 license验证 #

license验证的具体实现。

/**
     * License校验类
     */
    public class LicenseVerify {
    
        private static Logger logger = LogManager.getLogger(LicenseVerify.class);
        /**
         * 证书subject
         */
        private String subject;
        /**
         * 公钥别称
         */
        private String publicAlias;
        /**
         * 访问公钥库的密码
         */
        private String storePass;
        /**
         * 证书生成路径
         */
        private String licensePath;
        /**
         * 密钥库存储路径
         */
        private String publicKeysStorePath;
        /**
         * LicenseManager
         */
        private LicenseManager licenseManager;
        /**
         * 标识证书是否安装成功
         */
        private boolean installSuccess;
    
        public LicenseVerify(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;
        }
    
        /**
         * 安装License证书，读取证书相关的信息, 在bean加入容器的时候自动调用
         */
        public void installLicense() {
            try {
                Preferences preferences = Preferences.userNodeForPackage(LicenseVerify.class);
    
                CipherParam cipherParam = new DefaultCipherParam(storePass);
    
                KeyStoreParam publicStoreParam = new CustomKeyStoreParam(LicenseVerify.class,
                        publicKeysStorePath,
                        publicAlias,
                        storePass,
                        null);
                LicenseParam licenseParam = new DefaultLicenseParam(subject, preferences, publicStoreParam, cipherParam);
    
                licenseManager = new CustomLicenseManager(licenseParam);
                licenseManager.uninstall();
                LicenseContent licenseContent = licenseManager.install(new File(licensePath));
                DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                installSuccess = true;
                logger.info("------------------------------- 证书安装成功 -------------------------------");
                logger.info(MessageFormat.format("证书有效期：{0} - {1}", format.format(licenseContent.getNotBefore()), format.format(licenseContent.getNotAfter())));
            } catch (Exception e) {
                installSuccess = false;
                logger.error("------------------------------- 证书安装成功 -------------------------------");
                logger.error(e);
            }
        }
    
        /**
         * 卸载证书，在bean从容器移除的时候自动调用
         */
        public void unInstallLicense() {
            if (installSuccess) {
                try {
                    licenseManager.uninstall();
                } catch (Exception e) {
                    // ignore
                }
            }
        }
    
        /**
         * 校验License证书
         */
        public boolean verify() {
            try {
                LicenseContent licenseContent = licenseManager.verify();
                return true;
            } catch (Exception e) {
                return false;
            }
        }
    
    }

把LicenseVerify类添加到Spring容器里面去。在LicenseVerify添加到spring容器的时候顺便调用LicenseVerify对象里面的installLicense()方法加载证书。

@Configuration
    public class LicenseConfig {
    
        /**
         * 证书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;
    
        @Bean(initMethod = "installLicense", destroyMethod = "unInstallLicense")
        public LicenseVerify licenseVerify() {
            return new LicenseVerify(subject, publicAlias, storePass, licensePath, publicKeysStorePath);
        }
    
    }

> application.yml文件需要的配置

#License相关配置
    license:
      subject: ioserver #主题
      publicAlias: publicCert #公钥别称
      storePass: a123456 #访问公钥的密码
      licensePath: D:\licenseTest\license.lic #license位置
      publicKeysStorePath: D:\licenseTest\publicCerts.keystore #公钥位置

license验证测试。

@SpringBootTest
    @RunWith(SpringRunner.class)
    public class LicenseTest {
    
        private LicenseVerify licenseVerify;
    
        @Autowired
        public void setLicenseVerify(LicenseVerify licenseVerify) {
            this.licenseVerify = licenseVerify;
        }
    
        @Test
        public void licenseVerify() {
           System.out.println("licese是否有效：" + licenseVerify.verify());
        }
    
    }

--------------------

代码也不是很复杂，所以很多地方咱们都是直接把代码贴出来了。最后给出源码的下载地址[https://github.com/tuacy/java-study][https_github.com_tuacy_java-study]。注意在license模块下面(**重要的事情在说遍在相关代码license文件夹下面**)。

[https_github.com_tuacy_java-study]: https://github.com/tuacy/java-study