您的位置: 首页  >  文章  >  javaEE防盗版-License开发

javaEE防盗版-License开发

分类: 文章 • 2025-02-04 14:06:04


本文转载自：http://blog.****.net/lee272616/article/details/55057311
以下为转载内容：

前言

开发的软件产品在交付使用的时候，往往会授权一段时间的试用期，这个时候license就派上用场了。不同于在代码中直接加上时间约束，需要重新授权的时候使用license可以避免修改源码，改动部署，授权方直接生成一个新的license发送给使用方替换掉原来的license文件即可。下面将讲述使用truelicense来实现license的生成和使用。Truelicense是一个开源的证书管理引擎，详细介绍见https://truelicense.java.net/
license于加密技术一起使用效果更好。
接下来介绍一下license授权机制的原理：
1、生成**对，方法有很多。
2、授权者保留私钥，使用私钥对包含授权信息（如使用截止日期，MAC地址等）的license进行数字签名。
3、公钥给使用者（放在验证的代码中使用），用于验证license是否符合使用条件。

使用方式

1. 生成**对

以下命令在dos命令行执行，注意当前执行目录，最后生成的**对即在该目录下：
1、首先要用KeyTool工具来生成私匙库：（-alias别名 –validity 3650表示10年有效）
keytool -genkey -alias privatekey -keystore privateKeys.store -validity 3650
 javaEE防盗版-License开发
这里口令使用了noryar123
 javaEE防盗版-License开发
这里的口令是：noryar456
这个时候，会在打开命令行的地方创建出一个文件，privateKeys.store


2、然后把私匙库内的证书导出到一个文件当中：
keytool -export -alias privatekey -file certfile.cer -keystore privateKeys.store
 javaEE防盗版-License开发
口令：noryar123


3、然后再把这个证书文件导入到公匙库：
keytool -import -alias publiccert -file certfile.cer -keystore publicCerts.store
 javaEE防盗版-License开发
这里的口令，用了：noryar123


最后生成文件privateKeys.store、publicCerts.store拷贝出来备用。
文件位置在用户目录下
C:\Users\Administrator
从上面我们可以看到，**一共有两种：1. **库，这个需要配置到服务器中。2. **，这个需要保护好，是创建私钥的时候用的

2. Maven

[plain] view plain copy
  1. <!-- https://mvnrepository.com/artifact/de.schlichtherle.truelicense/truelicense-core -->  
  2. <dependency>  
  3.     <groupId>de.schlichtherle.truelicense</groupId>  
  4.     <artifactId>truelicense-core</artifactId>  
  5.     <version>1.33</version>  
  6. </dependency>  
  7. <!-- https://mvnrepository.com/artifact/de.schlichtherle.truelicense/truelicense-xml -->  
  8. <dependency>  
  9.     <groupId>de.schlichtherle.truelicense</groupId>  
  10.     <artifactId>truelicense-xml</artifactId>  
  11.     <version>1.33</version>  
  12. </dependency>  
  13. <!-- https://mvnrepository.com/artifact/commons-codec/commons-codec -->  
  14. <dependency>  
  15.     <groupId>commons-codec</groupId>  
  16.     <artifactId>commons-codec</artifactId>  
  17.     <version>1.10</version>  
  18. </dependency>  
  19. <!-- https://mvnrepository.com/artifact/de.schlichtherle.truelicense/truelicense-swing -->  
  20. <dependency>  
  21.     <groupId>de.schlichtherle.truelicense</groupId>  
  22.     <artifactId>truelicense-swing</artifactId>  
  23.     <version>1.33</version>  
  24. </dependency>  

3. 生成证书 (该部分代码由授权者独立保管执行)

[java] view plain copy
  1. package com.noryar.license;  
  2. import de.schlichtherle.license.LicenseManager;  
  3. import de.schlichtherle.license.LicenseParam;  
  4. /** 
  5.  * 单例模式下的证书管理器 
  6.  * @author Leon Lee. 
  7.  */  
  8. public class LicenseManagerHolder  
  9. {  
  10.     private static LicenseManager licenseManager;  
  11.     private LicenseManagerHolder(){}  
  12.     public static synchronized  LicenseManager getLicenseManager(LicenseParam param)  
  13.     {  
  14.         if(licenseManager==null)  
  15.         {  
  16.             licenseManager=new LicenseManager(param);  
  17.         }  
  18.         return licenseManager;  
  19.     }  
  20. }  

[java] view plain copy
  1. package com.noryar.license;  
  2.   
  3. import java.io.File;  
  4. import java.io.IOException;  
  5. import java.io.InputStream;  
  6. import java.text.ParseException;  
  7. import java.text.SimpleDateFormat;  
  8. import java.util.Properties;  
  9. import java.util.prefs.Preferences;  
  10.   
  11. import javax.security.auth.x500.X500Principal;  
  12.   
  13. import de.schlichtherle.license.CipherParam;  
  14. import de.schlichtherle.license.DefaultCipherParam;  
  15. import de.schlichtherle.license.DefaultKeyStoreParam;  
  16. import de.schlichtherle.license.DefaultLicenseParam;  
  17. import de.schlichtherle.license.KeyStoreParam;  
  18. import de.schlichtherle.license.LicenseContent;  
  19. import de.schlichtherle.license.LicenseManager;  
  20. import de.schlichtherle.license.LicenseParam;  
  21.   
  22. /** 
  23.  * 生成证书 
  24.  * @author Leon Lee. 
  25.  */  
  26. public class LicenseMake  
  27. {  
  28.     private String licPath;  
  29.     private String issued ;  
  30.     private String notBefore ;  
  31.     private String notAfter ;  
  32.     private String consumerType;  
  33.     private int consumerAmount ;  
  34.     private String info ;  
  35.     /** 
  36.      * 私钥的别名 
  37.      */  
  38.     private String priAlias ;  
  39.     /** 
  40.      * 该密码生成**对的密码 
  41.      */  
  42.     private String privateKeyPwd ;  
  43.     /** 
  44.      * 使用keytool生成**对时设置的**库的访问密码 
  45.      */  
  46.     private String keyStorePwd ;  
  47.     private String subject ;  
  48.     private String priPath ;  
  49.       
  50.     // X500Princal是一个证书文件的固有格式，详见API  
  51.     private final static X500Principal DEFAULTHOLDERANDISSUER = new X500Principal("CN=noryar, OU=noryar, O=noryar, L=china, ST=dalian, C=china");  
  52.       
  53.     public LicenseMake(){}  
  54.     public LicenseMake(String confPath)  
  55.     {  
  56.         initParam(confPath);  
  57.     }  
  58.       
  59.     /** 
  60.      * 读取属性文件 
  61.      * @param propertiesPath 属性文件路径 
  62.      */  
  63.     public void initParam(String confPath)   
  64.     {  
  65.         // 获取参数  
  66.         Properties prop = new Properties();  
  67.         InputStream in = getClass().getResourceAsStream(confPath);  
  68.         try  
  69.         {  
  70.             prop.load(in);  
  71.         }  
  72.         catch (IOException e)  
  73.         {  
  74.             e.printStackTrace();  
  75.         }  
  76.         //common param  
  77.         priAlias = prop.getProperty("private.key.alias");  
  78.         privateKeyPwd = prop.getProperty("private.key.pwd");  
  79.         keyStorePwd= prop.getProperty("key.store.pwd");  
  80.         subject = prop.getProperty("subject");  
  81.         priPath = prop.getProperty("priPath");  
  82.         licPath = prop.getProperty("licPath");  
  83.          // license content  
  84.         issued = prop.getProperty("issuedTime");  
  85.         notBefore = prop.getProperty("notBefore");  
  86.         notAfter = prop.getProperty("notAfter");  
  87.         consumerType = prop.getProperty("consumerType");  
  88.         consumerAmount = Integer.valueOf(prop.getProperty("consumerAmount"));  
  89.         info = prop.getProperty("info");  
  90.     }  
  91.       
  92.     /** 
  93.      * 初始化证书的相关参数 
  94.      * @return 
  95.      */  
  96.     private LicenseParam initLicenseParams()  
  97.     {  
  98.         Class<LicenseMake> clazz=LicenseMake.class;  
  99.         Preferences pre = Preferences.userNodeForPackage(clazz);  
  100.         // 设置对证书内容加密的对称密码  
  101.         CipherParam cipherParam = new DefaultCipherParam(keyStorePwd);  
  102.         // 参数1,2从哪个Class.getResource()获得**库;  
  103.         //参数3**库的别名;  
  104.         //参数4**库存储密码;  
  105.         //参数5**库密码  
  106.         KeyStoreParam privateStoreParam = new DefaultKeyStoreParam(clazz, priPath, priAlias, keyStorePwd, privateKeyPwd);  
  107.         // 返回生成证书时需要的参数  
  108.         LicenseParam licenseParam = new DefaultLicenseParam(subject,pre, privateStoreParam, cipherParam);  
  109.         return licenseParam;  
  110.     }  
  111.       
  112.     /** 
  113.      * 通过外部配置文件构建证书的的相关信息 
  114.      * @return 
  115.      * @throws ParseException 
  116.      */  
  117.     public LicenseContent buildLicenseContent() throws ParseException  
  118.     {  
  119.         LicenseContent content=new LicenseContent();  
  120.         SimpleDateFormat formate=new SimpleDateFormat("yyyy-MM-dd");  
  121.         content.setConsumerAmount(consumerAmount);  
  122.         content.setConsumerType(consumerType);  
  123.         content.setHolder(DEFAULTHOLDERANDISSUER);  
  124.         content.setIssuer(DEFAULTHOLDERANDISSUER);  
  125.         content.setIssued(formate.parse(issued));  
  126.         content.setNotBefore(formate.parse(notBefore));  
  127.         content.setNotAfter(formate.parse(notAfter));  
  128.         content.setInfo(info);  
  129.         content.setExtra(new Object());  
  130.         return content;  
  131.     }  
  132.       
  133.       
  134.     /** 
  135.      * 生成证书，在证书发布者端执行 
  136.      * @throws Exception  
  137.      */  
  138.     public void create() throws Exception  
  139.     {  
  140.         LicenseManager licenseManager=LicenseManagerHolder.getLicenseManager(initLicenseParams());  
  141.         LicenseContent content=buildLicenseContent();  
  142.         licenseManager.store(content, new File(licPath));  
  143.         System.out.println("证书发布成功");  
  144.     }  
  145. }  

licenseMakeConf.properties

[plain] view plain copy
  1. ##########common parameters###########  
  2. #私钥的别名  
  3. private.key.alias=privatekey  
  4. #privateKeyPwd(该密码生成**对的密码，需要妥善保管，不能让使用者知道)  
  5. private.key.pwd=noryar456  
  6. #keyStorePwd(该密码是在使用keytool生成**对时设置的**库的访问密码)  
  7. key.store.pwd=noryar123  
  8. #项目的唯一识别码  
  9. subject=noryar  
  10. #生成证书的地址  
  11. licPath=license.lic  
  12. #**库的地址  
  13. priPath=privateKeys.store  
  14. ##########license content###########  
  15. #发布日期  
  16. issuedTime=2016-07-25  
  17. #有效开始日期  
  18. notBefore=2016-07-25  
  19. #有效截止日期  
  20. notAfter=2016-08-30  
  21. #consumerType  
  22. consumerType=user  
  23. #ConsumerAmount  
  24. consumerAmount=1  
  25. #info  
  26. info=this is a license  

测试方法

[java] view plain copy
  1. public static void main(String[] args) throws Exception  
  2.     {  
  3.         LicenseMake clicense=new LicenseMake("/licenseMakeConf.properties");  
  4.         clicense.create();  
  5.     }  
以上就可以创建出一个license文件了。然后开发者将license文件传递给购买方。购买方在系统中上传该文件进行验证即可。


4. 验证证书

[java] view plain copy
  1. package com.noryar.license;  
  2.   
  3. import de.schlichtherle.license.LicenseManager;  
  4. import de.schlichtherle.license.LicenseParam;  
  5. /** 
  6.  * 单例模式下的证书管理器 
  7.  * @author Leon Lee 
  8.  */  
  9. public class LicenseManagerHolder  
  10. {  
  11.     private static LicenseManager licenseManager;  
  12.     private LicenseManagerHolder(){}  
  13.     public static synchronized  LicenseManager getLicenseManager(LicenseParam param)  
  14.     {  
  15.         if(licenseManager==null)  
  16.         {  
  17.             licenseManager=new LicenseManager(param);  
  18.         }  
  19.         return licenseManager;  
  20.     }  
  21. }  

认证核心方法

[java] view plain copy
  1. package com.noryar.license;  
  2.   
  3. import java.io.File;  
  4. import java.io.IOException;  
  5. import java.io.InputStream;  
  6. import java.util.Properties;  
  7. import java.util.prefs.Preferences;  
  8.   
  9. import de.schlichtherle.license.CipherParam;  
  10. import de.schlichtherle.license.DefaultCipherParam;  
  11. import de.schlichtherle.license.DefaultKeyStoreParam;  
  12. import de.schlichtherle.license.DefaultLicenseParam;  
  13. import de.schlichtherle.license.KeyStoreParam;  
  14. import de.schlichtherle.license.LicenseContentException;  
  15. import de.schlichtherle.license.LicenseManager;  
  16. import de.schlichtherle.license.LicenseParam;  
  17.   
  18. public class LicenseVertify  
  19. {  
  20.     /** 
  21.      * 公钥别名 
  22.      */  
  23.     private String pubAlias;  
  24.     /** 
  25.      * 该密码是在使用keytool生成**对时设置的**库的访问密码  
  26.      */  
  27.     private String keyStorePwd;  
  28.     /** 
  29.      * 系统的统一识别码 
  30.      */  
  31.     private String onlykey;  
  32.     /** 
  33.      * 证书路径  
  34.      */  
  35.     private String licName;  
  36.     /** 
  37.      * 公钥库路径 
  38.      */  
  39.     private String pubPath;  
  40.     private String confPath="/licenseVertifyConf.properties";  
  41.     public LicenseVertify(String onlykey)  
  42.     {  
  43.         setConf(confPath,onlykey);  
  44.     }  
  45.       
  46.     public LicenseVertify(String confPath,String onlykey)  
  47.     {  
  48.         setConf(confPath,onlykey);  
  49.     }  
  50.     /** 
  51.      * 通过外部配置文件获取配置信息 
  52.      * @param confPath  配置文件路径 
  53.      * @param onlykey 系统的统一识别码 
  54.      */  
  55.     public void setConf(String confPath,String onlykey)  
  56.     {  
  57.         // 获取参数  
  58.         Properties prop = new Properties();  
  59.         InputStream in = getClass().getResourceAsStream(confPath);  
  60.         try  
  61.         {  
  62.             prop.load(in);  
  63.         }  
  64.         catch (IOException e)  
  65.         {  
  66.             e.printStackTrace();  
  67.         }  
  68.           
  69.         this.onlykey=onlykey;  
  70.         pubAlias = prop.getProperty("public.alias");  
  71.         keyStorePwd = prop.getProperty("key.store.pwd");  
  72.         licName = prop.getProperty("license.name");  
  73.         pubPath = prop.getProperty("public.store.path");  
  74.           
  75.     }  
  76.       
  77.     /** 
  78.      * 初始化证书的相关参数 
  79.      * @param 系统的统一识别码 
  80.      * @return 
  81.      */  
  82.     private LicenseParam initLicenseParams()  
  83.     {  
  84.         Class<LicenseVertify> clazz=LicenseVertify.class;  
  85.         Preferences pre=Preferences.userNodeForPackage(clazz);  
  86.         CipherParam cipherParam=new DefaultCipherParam(storePwd);  
  87.         KeyStoreParam pubStoreParam=new DefaultKeyStoreParam(clazz, pubPath, pubAlias, keyStorePwd, null);  
  88.         LicenseParam licenseParam=new DefaultLicenseParam(onlykey, pre, pubStoreParam, cipherParam);  
  89.         return licenseParam;  
  90.     }  
  91.       
  92.     private LicenseManager getLicenseManager()  
  93.     {  
  94.         return LicenseManagerHolder.getLicenseManager(initLicenseParams());  
  95.     }  
  96.     /** 
  97.      * 安装证书证书 
  98.      * @param 存放证书的路径 
  99.      * @return 
  100.      */  
  101.     public void install(String licdir)  
  102.     {  
  103.         try  
  104.         {  
  105.             LicenseManager licenseManager=getLicenseManager();  
  106.             licenseManager.install(new File(licdir+File.separator+licName));  
  107.             System.out.println("安装证书成功!");  
  108.         }  
  109.         catch (Exception e)  
  110.         {  
  111.             System.out.println("安装证书失败!");  
  112.             e.printStackTrace();  
  113.             System.exit(0);  
  114.         }  
  115.           
  116.     }  
  117.       
  118.     /** 
  119.      * 验证证书的合法性 
  120.      * @return 0、合法，1、证书过期，2、证书错误 
  121.      */  
  122.     public int vertify()  
  123.     {  
  124.         try  
  125.         {  
  126.             LicenseManager licenseManager=getLicenseManager();  
  127.             licenseManager.verify();  
  128.             System.out.println("验证证书成功!");  
  129.             return 0;  
  130.         }  
  131.         catch(LicenseContentException ex)  
  132.         {  
  133.             System.out.println("证书已经过期!");  
  134.             ex.printStackTrace();  
  135.             return 1;  
  136.         }  
  137.         catch (Exception e)  
  138.         {  
  139.             System.out.println("验证证书失败!");  
  140.             e.printStackTrace();  
  141.             return 2;  
  142.         }  
  143.     }  
  144. }  

测试

[java] view plain copy
  1. public static void main(String[] args) throws Exception  
  2.     {  
  3.         LicenseVertify vlicense=new LicenseVertify("noryar"); // 项目唯一识别码，对应生成配置文件的subject  
  4.         vlicense.install(System.getProperty("user.dir"));  
  5.         vlicense.vertify();  
  6.     }  
licenseVertifyConf.properties

[plain] view plain copy
  1. ##########common parameters###########  
  2. #公钥别名  
  3. public.alias=publiccert  
  4. #使用keytool生成**对时设置的**库的访问密码  
  5. key.store.pwd= noryar123  
  6. #证书路径  
  7. license.name=license.lic  
  8. #公共库路径  
  9. public.store.path=publicCerts.store  

总结

以上就是license开发的常规手段。对于web项目来说，只需要提供license认证模块的开发即可。对于开发者来说，可以将license生成单独开发一个小程序。以后就可以通过这个程序来给不同的企业生成license。

此外，为了更好的保护代码。license认证模块可以进行混淆加密，解密部分使用C语言来编写，同时针对不同的平台进行编译。增强**难度。

版权声明：本文为博主原创文章，转载请附明出处。

相关推荐