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地址