使用truelicense实现用于JAVA工程license机制（包括license生成和验证）

http://www.it165.net/pro/html/201404/11540.html

开发的软件产品在交付使用的时候，往往会授权一段时间的试用期，这个时候license就派上用场了。不同于在代码中直接加上时间约束，需要重新授权的时候使用license可以避免修改源码，改动部署，授权方直接生成一个新的license发送给使用方替换掉原来的license文件即可。下面将讲述使用truelicense来实现license的生成和使用。Truelicense是一个开源的证书管理引擎，详细介绍见https://truelicense.java.net/

一、首先介绍下license授权机制的原理：

1、生成密钥对，方法有很多。

2、授权者保留私钥，使用私钥对包含授权信息（如使用截止日期，MAC地址等）的license进行数字签名。

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

接下来是本例制作license的具体步骤：

二、第一步：使用keytool生成密钥对

以下命令在dos命令行执行，注意当前执行目录，最后生成的密钥对即在该目录下：

1、首先要用KeyTool工具来生成私匙库：（-alias别名 –validity 3650表示10年有效）

keytool -genkey -alias privatekey -keystoreprivateKeys.store -validity 3650

2、然后把私匙库内的公匙导出到一个文件当中：

1. keytool -export -alias privatekey -file certfile.cer -keystore privateKeys.store

3、然后再把这个证书文件导入到公匙库：

1. keytool -import -alias publiccert -file certfile.cer -keystore publicCerts.store

最后生成文件privateKeys.store、publicCerts.store拷贝出来备用。

三、第二步：生成证书（该部分代码由授权者独立保管执行）

1、首先LicenseManagerHolder.java类：

 
   01. 
   package cn.melina.license; 
  
   02. 
   import de.schlichtherle.license.LicenseManager; 
  
   03. 
   import de.schlichtherle.license.LicenseParam; 
  
   04. 
     
   05. 
   /** 
  
   06. 
   * LicenseManager?????? 
  
   07. 
   * @author melina 
  
   08. 
   */ 
  
   09. 
   public class LicenseManagerHolder { 
  
   10. 
     
   11. 
   private static LicenseManager licenseManager; 
  
   12. 
     
   13. 
   public static synchronized LicenseManager getLicenseManager(LicenseParam licenseParams) { 
  
   14. 
   if (licenseManager == null) { 
  
   15. 
   licenseManager = new LicenseManager(licenseParams); 
  
   16. 
   } 
  
   17. 
   return licenseManager; 
  
   18. 
   } 
  
   19. 
   }

2、然后是主要生成license的代码CreateLicense.java：

 
   001. 
   package cn.melina.license; 
  
   002. 
     
   003. 
   import java.io.File; 
  
   004. 
   import java.io.IOException; 
  
   005. 
   import java.io.InputStream; 
  
   006. 
   import java.text.DateFormat; 
  
   007. 
   import java.text.ParseException; 
  
   008. 
   import java.text.SimpleDateFormat; 
  
   009. 
   import java.util.Properties; 
  
   010. 
   import java.util.prefs.Preferences; 
  
   011. 
   import javax.security.auth.x500.X500Principal; 
  
   012. 
   import de.schlichtherle.license.CipherParam; 
  
   013. 
   import de.schlichtherle.license.DefaultCipherParam; 
  
   014. 
   import de.schlichtherle.license.DefaultKeyStoreParam; 
  
   015. 
   import de.schlichtherle.license.DefaultLicenseParam; 
  
   016. 
   import de.schlichtherle.license.KeyStoreParam; 
  
   017. 
   import de.schlichtherle.license.LicenseContent; 
  
   018. 
   import de.schlichtherle.license.LicenseParam; 
  
   019. 
   import de.schlichtherle.license.LicenseManager; 
  
   020. 
     
   021. 
   /** 
  
   022. 
   * CreateLicense 
  
   023. 
   * @author melina 
  
   024. 
   */ 
  
   025. 
   public class CreateLicense { 
  
   026. 
   //common param 
  
   027. 
   private static String PRIVATEALIAS = ""; 
  
   028. 
   private static String KEYPWD = ""; 
  
   029. 
   private static String STOREPWD = ""; 
  
   030. 
   private static String SUBJECT = ""; 
  
   031. 
   private static String licPath = ""; 
  
   032. 
   private static String priPath = ""; 
  
   033. 
   //license content 
  
   034. 
   private static String issuedTime = ""; 
  
   035. 
   private static String notBefore = ""; 
  
   036. 
   private static String notAfter = ""; 
  
   037. 
   private static String consumerType = ""; 
  
   038. 
   private static int consumerAmount = 0; 
  
   039. 
   private static String info = ""; 
  
   040. 
   // 为了方便直接用的API里的例子 
  
   041. 
   // X500Princal是一个证书文件的固有格式，详见API 
  
   042. 
   private final static X500Principal DEFAULTHOLDERANDISSUER = new X500Principal( 
  
   043. 
   "CN=Duke、OU=JavaSoft、O=Sun Microsystems、C=US"); 
  
   044. 
     
   045. 
   public void setParam(String propertiesPath) { 
  
   046. 
   // 获取参数 
  
   047. 
   Properties prop = new Properties(); 
  
   048. 
   InputStream in = getClass().getResourceAsStream(propertiesPath); 
  
   049. 
   try { 
  
   050. 
   prop.load(in); 
  
   051. 
   } catch (IOException e) { 
  
   052. 
   // TODO Auto-generated catch block 
  
   053. 
   e.printStackTrace(); 
  
   054. 
   } 
  
   055. 
   PRIVATEALIAS = prop.getProperty("PRIVATEALIAS"); 
  
   056. 
   KEYPWD = prop.getProperty("KEYPWD"); 
  
   057. 
   STOREPWD = prop.getProperty("STOREPWD"); 
  
   058. 
   SUBJECT = prop.getProperty("SUBJECT"); 
  
   059. 
   KEYPWD = prop.getProperty("KEYPWD"); 
  
   060. 
   licPath = prop.getProperty("licPath"); 
  
   061. 
   priPath = prop.getProperty("priPath"); 
  
   062. 
   //license content 
  
   063. 
   issuedTime = prop.getProperty("issuedTime"); 
  
   064. 
   notBefore = prop.getProperty("notBefore"); 
  
   065. 
   notAfter = prop.getProperty("notAfter"); 
  
   066. 
   consumerType = prop.getProperty("consumerType"); 
  
   067. 
   consumerAmount = Integer.valueOf(prop.getProperty("consumerAmount")); 
  
   068. 
   info = prop.getProperty("info"); 
  
   069. 
     
   070. 
   } 
  
   071. 
     
   072. 
   public boolean create() {       
  
   073. 
   try { 
  
   074. 
   /************** 证书发布者端执行 ******************/ 
  
   075. 
   LicenseManager licenseManager = LicenseManagerHolder 
  
   076. 
   .getLicenseManager(initLicenseParams0()); 
  
   077. 
   licenseManager.store((createLicenseContent()), new File(licPath));  
  
   078. 
   } catch (Exception e) { 
  
   079. 
   e.printStackTrace(); 
  
   080. 
   System.out.println("客户端证书生成失败!"); 
  
   081. 
   return false; 
  
   082. 
   } 
  
   083. 
   System.out.println("服务器端生成证书成功!"); 
  
   084. 
   return true; 
  
   085. 
   } 
  
   086. 
     
   087. 
   // 返回生成证书时需要的参数 
  
   088. 
   private static LicenseParam initLicenseParams0() { 
  
   089. 
   Preferences preference = Preferences 
  
   090. 
   .userNodeForPackage(CreateLicense.class); 
  
   091. 
   // 设置对证书内容加密的对称密码 
  
   092. 
   CipherParam cipherParam = new DefaultCipherParam(STOREPWD); 
  
   093. 
   // 参数1,2从哪个Class.getResource()获得密钥库;参数3密钥库的别名;参数4密钥库存储密码;参数5密钥库密码 
  
   094. 
   KeyStoreParam privateStoreParam = new DefaultKeyStoreParam( 
  
   095. 
   CreateLicense.class, priPath, PRIVATEALIAS, STOREPWD, KEYPWD); 
  
   096. 
   LicenseParam licenseParams = new DefaultLicenseParam(SUBJECT, 
  
   097. 
   preference, privateStoreParam, cipherParam); 
  
   098. 
   return licenseParams; 
  
   099. 
   } 
  
   100. 
     
   101. 
   // 从外部表单拿到证书的内容 
  
   102. 
   public final static LicenseContent createLicenseContent() { 
  
   103. 
   DateFormat format = new SimpleDateFormat("yyyy-MM-dd"); 
  
   104. 
   LicenseContent content = null; 
  
   105. 
   content = new LicenseContent(); 
  
   106. 
   content.setSubject(SUBJECT); 
  
   107. 
   content.setHolder(DEFAULTHOLDERANDISSUER); 
  
   108. 
   content.setIssuer(DEFAULTHOLDERANDISSUER); 
  
   109. 
   try { 
  
   110. 
   content.setIssued(format.parse(issuedTime)); 
  
   111. 
   content.setNotBefore(format.parse(notBefore)); 
  
   112. 
   content.setNotAfter(format.parse(notAfter)); 
  
   113. 
   } catch (ParseException e) { 
  
   114. 
   // TODO Auto-generated catch block 
  
   115. 
   e.printStackTrace(); 
  
   116. 
   } 
  
   117. 
   content.setConsumerType(consumerType); 
  
   118. 
   content.setConsumerAmount(consumerAmount); 
  
   119. 
   content.setInfo(info); 
  
   120. 
   // 扩展 
  
   121. 
   content.setExtra(new Object()); 
  
   122. 
   return content; 
  
   123. 
   } 
  
   124. 
   }

3、测试程序licenseCreateTest.java：

 
   01. 
   package cn.melina.license; 
  
   02. 
   import cn.melina.license.CreateLicense; 
  
   03. 
   public class licenseCreateTest { 
  
   04. 
   public static void main(String[] args){ 
  
   05. 
   CreateLicense cLicense = new CreateLicense(); 
  
   06. 
   //获取参数 
  
   07. 
   cLicense.setParam("./param.properties"); 
  
   08. 
   //生成证书 
  
   09. 
   cLicense.create(); 
  
   10. 
   } 
  
   11. 
   }

4、生成时使用到的param.properties文件如下：

 
   01. 
   ##########common parameters########### 
  
   02. 
   #alias 
  
   03. 
   PRIVATEALIAS=privatekey 
  
   04. 
   #key(该密码生成密钥对的密码，需要妥善保管，不能让使用者知道) 
  
   05. 
   KEYPWD=bigdata123456 
  
   06. 
   #STOREPWD(该密码是在使用keytool生成密钥对时设置的密钥库的访问密码) 
  
   07. 
   STOREPWD=abc123456 
  
   08. 
   #SUBJECT 
  
   09. 
   SUBJECT=bigdata 
  
   10. 
   #licPath 
  
   11. 
   licPath=bigdata.lic 
  
   12. 
   #priPath 
  
   13. 
   priPath=privateKeys.store 
  
   14. 
   ##########license content########### 
  
   15. 
   #issuedTime 
  
   16. 
   issuedTime=2014-04-01 
  
   17. 
   #notBeforeTime 
  
   18. 
   notBefore=2014-04-01 
  
   19. 
   #notAfterTime 
  
   20. 
   notAfter=2014-05-01 
  
   21. 
   #consumerType 
  
   22. 
   consumerType=user 
  
   23. 
   #ConsumerAmount 
  
   24. 
   consumerAmount=1 
  
   25. 
   #info 
  
   26. 
   info=this is a license

根据properties文件可以看出，这里只简单设置了使用时间的限制，当然可以自定义添加更多限制。该文件中表示授权者拥有私钥，并且知道生成密钥对的密码。并且设置license的内容。

四、第三步：验证证书（使用证书）（该部分代码结合需要授权的程序使用）

1、首先LicenseManagerHolder.java类，同上。

2、然后是主要验证license的代码VerifyLicense.java：

 
   01. 
   package cn.melina.license; 
  
   02. 
     
   03. 
   import java.io.File; 
  
   04. 
   import java.io.IOException; 
  
   05. 
   import java.io.InputStream; 
  
   06. 
   import java.util.Properties; 
  
   07. 
   import java.util.prefs.Preferences; 
  
   08. 
     
   09. 
   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.LicenseParam; 
  
   15. 
   import de.schlichtherle.license.LicenseManager; 
  
   16. 
     
   17. 
   /** 
  
   18. 
   * VerifyLicense 
  
   19. 
   * @author melina 
  
   20. 
   */ 
  
   21. 
   public class VerifyLicense { 
  
   22. 
   //common param 
  
   23. 
   private static String PUBLICALIAS = ""; 
  
   24. 
   private static String STOREPWD = ""; 
  
   25. 
   private static String SUBJECT = ""; 
  
   26. 
   private static String licPath = ""; 
  
   27. 
   private static String pubPath = ""; 
  
   28. 
     
   29. 
   public void setParam(String propertiesPath) { 
  
   30. 
   // 获取参数 
  
   31. 
   Properties prop = new Properties(); 
  
   32. 
   InputStream in = getClass().getResourceAsStream(propertiesPath); 
  
   33. 
   try { 
  
   34. 
   prop.load(in); 
  
   35. 
   } catch (IOException e) { 
  
   36. 
   // TODO Auto-generated catch block 
  
   37. 
   e.printStackTrace(); 
  
   38. 
   } 
  
   39. 
   PUBLICALIAS = prop.getProperty("PUBLICALIAS"); 
  
   40. 
   STOREPWD = prop.getProperty("STOREPWD"); 
  
   41. 
   SUBJECT = prop.getProperty("SUBJECT"); 
  
   42. 
   licPath = prop.getProperty("licPath"); 
  
   43. 
   pubPath = prop.getProperty("pubPath"); 
  
   44. 
   } 
  
   45. 
     
   46. 
   public boolean verify() {       
  
   47. 
   /************** 证书使用者端执行 ******************/ 
  
   48. 
     
   49. 
   LicenseManager licenseManager = LicenseManagerHolder 
  
   50. 
   .getLicenseManager(initLicenseParams()); 
  
   51. 
   // 安装证书 
  
   52. 
   try { 
  
   53. 
   licenseManager.install(new File(licPath)); 
  
   54. 
   System.out.println("客户端安装证书成功!"); 
  
   55. 
   } catch (Exception e) { 
  
   56. 
   e.printStackTrace(); 
  
   57. 
   System.out.println("客户端证书安装失败!"); 
  
   58. 
   return false; 
  
   59. 
   } 
  
   60. 
   // 验证证书 
  
   61. 
   try { 
  
   62. 
   licenseManager.verify(); 
  
   63. 
   System.out.println("客户端验证证书成功!"); 
  
   64. 
   } catch (Exception e) { 
  
   65. 
   e.printStackTrace(); 
  
   66. 
   System.out.println("客户端证书验证失效!"); 
  
   67. 
   return false; 
  
   68. 
   } 
  
   69. 
   return true; 
  
   70. 
   } 
  
   71. 
     
   72. 
   // 返回验证证书需要的参数 
  
   73. 
   private static LicenseParam initLicenseParams() { 
  
   74. 
   Preferences preference = Preferences 
  
   75. 
   .userNodeForPackage(VerifyLicense.class); 
  
   76. 
   CipherParam cipherParam = new DefaultCipherParam(STOREPWD); 
  
   77. 
     
   78. 
   KeyStoreParam privateStoreParam = new DefaultKeyStoreParam( 
  
   79. 
   VerifyLicense.class, pubPath, PUBLICALIAS, STOREPWD, null); 
  
   80. 
   LicenseParam licenseParams = new DefaultLicenseParam(SUBJECT, 
  
   81. 
   preference, privateStoreParam, cipherParam); 
  
   82. 
   return licenseParams; 
  
   83. 
   } 
  
   84. 
   }

3、测试程序licenseVerifyTest.java：

 
   01. 
   package cn.melina.license; 
  
   02. 
     
   03. 
   public class licenseVerifyTest { 
  
   04. 
   public static void main(String[] args){ 
  
   05. 
   VerifyLicense vLicense = new VerifyLicense(); 
  
   06. 
   //获取参数 
  
   07. 
   vLicense.setParam("./param.properties"); 
  
   08. 
   //验证证书 
  
   09. 
   vLicense.verify(); 
  
   10. 
   } 
  
   11. 
   }

4、验证时使用到的Properties文件如下：

 
   01. 
   ##########common parameters########### 
  
   02. 
   #alias 
  
   03. 
   PUBLICALIAS=publiccert 
  
   04. 
   #STOREPWD(该密码是在使用keytool生成密钥对时设置的密钥库的访问密码) 
  
   05. 
   STOREPWD=abc123456 
  
   06. 
   #SUBJECT 
  
   07. 
   SUBJECT=bigdata 
  
   08. 
   #licPath 
  
   09. 
   licPath=bigdata.lic 
  
   10. 
   #pubPath 
  
   11. 
   pubPath=publicCerts.store

根据该验证的properties可以看出，使用者只拥有公钥，没有私钥，并且也只知道访问密钥库的密码，而不能知道生成密钥对的密码。

五、说明：

注意实际操作中，公钥、私钥、证书等文件的存放路径。

以上代码需要用到truelicense的一些包，可以自行网上搜，也可以下载我的完整工程，里面附带了所需的jar包。

http://blog.csdn.net/jingshuaizh/article/details/44461289

使用truelicense进行Java程序license控制经过扩张可以验证license 开始结束日期，验证绑定给定mac地址

使用truelicense实现用于JAVA工程license机制（包括license生成和验证）

猜你喜欢