package org.sxkj.common.utils.license;
|
|
import java.io.*;
|
import java.security.PrivateKey;
|
import java.security.PublicKey;
|
import java.text.DateFormat;
|
import java.text.SimpleDateFormat;
|
import java.util.*;
|
|
import org.apache.commons.codec.binary.Base64;
|
import org.apache.commons.io.FileUtils;
|
import org.apache.commons.lang.StringUtils;
|
import org.apache.http.client.utils.DateUtils;
|
import org.sxkj.common.constant.CommonConstant;
|
|
/**
|
* 这个类，在打包的时候，不发布到现场。
|
*
|
* @author stzhang
|
*/
|
public class LicenseUtils {
|
public final static String licenseSourceFileName = "LICENSE.txt";
|
public final static String licenseFileName = "LICENSE.lic";
|
|
public static void initLicensePath(String licenseFilePath, LicenseData licenseData) {
|
System.out.println("-----------开始初始化路径-----------");
|
try {
|
String[] content = convertLicenseDataToFileContent(licenseData);
|
|
initLicensePath(licenseFilePath, licenseSourceFileName, content);
|
} catch (Exception e) {
|
System.out.println(e.getMessage());
|
}
|
System.out.println("-----------初始化路径完成-----------");
|
}
|
|
|
/**
|
* 初始化 License
|
*
|
* @param licenseData
|
* @return
|
*/
|
public static byte[] genLicenseFile( LicenseData licenseData) {
|
System.out.println("-----------开始生成证书-----------");
|
String[] content = convertLicenseDataToFileContent(licenseData);
|
byte[] bytes;
|
try {
|
bytes = genLicenseFile(content);
|
} catch (Exception e) {
|
throw new RuntimeException(e);
|
}
|
|
|
System.out.println("-----------生成证书完成-----------");
|
return bytes;
|
}
|
|
/**
|
* 初始化目录
|
*
|
* @param licensePath
|
* @param sourceFileName
|
* @param defaultLicenseContent
|
* @throws Exception
|
*/
|
private static void initLicensePath(String licensePath, String sourceFileName, String[] defaultLicenseContent) throws Exception {
|
File file = new File(licensePath + File.separator + sourceFileName);
|
File filePath = new File(licensePath);
|
if (filePath.exists()) {
|
System.out.println("路径已经存在:" + filePath.getAbsolutePath());
|
} else {
|
filePath.mkdirs();
|
}
|
if (file.exists()) {
|
System.out.println("License源文件已经存在:" + file.getAbsolutePath());
|
} else {
|
List<String> lines = new ArrayList<String>();
|
for (int j = 0, len = defaultLicenseContent.length; j < len; j++) {
|
if (StringUtils.isNotEmpty(defaultLicenseContent[j])) {
|
lines.add(defaultLicenseContent[j]);
|
}
|
}
|
FileUtils.writeLines(file, "UTF-8", lines);
|
System.out.println("初始化路径完成:" + file.getAbsolutePath());
|
}
|
|
}
|
|
|
/**
|
* 生成证书License文件
|
*
|
* @param defaultLicenseContent： 默认产生的内容
|
* @throws Exception
|
*/
|
private static byte[] genLicenseFile( String[] defaultLicenseContent) throws Exception {
|
// 加载证书
|
PrivateKey privateKey = RSAEnCoder.getPrivateKey(CryptoPrivateKeys.KEYMODULUS, CryptoPrivateKeys.PRIVATEKEYEXPONENT);
|
|
byte[] sByte = stringArrayToBytesWithEncoding(defaultLicenseContent, "UTF-8");
|
byte[] encoderData = RSAEnCoder.encryptRSA(sByte, privateKey);
|
String sign = RSAEnCoder.sign(encoderData, privateKey);
|
//把签名也写进证书， 进行License的自我校验。
|
byte[] signBytes = ("\n" + sign).getBytes();
|
byte[] raw = new byte[encoderData.length + signBytes.length];
|
//合并两个byte[]
|
System.arraycopy(encoderData, 0, raw, 0, encoderData.length);
|
System.arraycopy(signBytes, 0, raw, encoderData.length, signBytes.length);
|
// 双重加密
|
byte[] encoderaw = RSAEnCoder.encryptRSA(raw, privateKey);
|
return encoderaw;
|
|
}
|
|
public static byte[] stringArrayToBytesWithEncoding(String[] strings, String charsetName)
|
throws UnsupportedEncodingException {
|
|
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
|
|
for (String str : strings) {
|
byte[] bytes = str.getBytes(charsetName); // 使用指定编码
|
outputStream.write(bytes, 0, bytes.length);
|
outputStream.write('\n'); // 可选：添加分隔符
|
}
|
|
return outputStream.toByteArray();
|
}
|
|
/**
|
* 校验证书文件
|
*
|
* @param licenseFilePath 文件路径
|
* @param currentDate 当前时间
|
* @return
|
* @throws Exception
|
*/
|
public static boolean checkLicense(String licenseFilePath, Date currentDate) throws Exception {
|
// 加载证书
|
PublicKey publicKey = RSADeCoder.getPublicKey(CryptoPublicKeys.KEYMODULUS, CryptoPublicKeys.PUBLICKEYEXPONENT);
|
File licenseFile = new File(licenseFilePath);
|
if (!licenseFile.exists()) {
|
throw new Exception("没有获取License文件");
|
}
|
FileInputStream fis = FileUtils.openInputStream(licenseFile);
|
if (fis.available() == 0) {
|
throw new FileNotFoundException("License加密文件为空");
|
}
|
fis.close();
|
//首先读入License文件
|
byte[] encoderData = FileUtils.readFileToByteArray(licenseFile);
|
byte[] sbytes = RSADeCoder.decryptRSA(encoderData, publicKey);
|
byte[] firstEncoderData = null;
|
byte[] secondSignData = null;
|
int index = 0;
|
for (int len = sbytes.length; index < len; index++) {
|
if (sbytes[index] == '\n') {
|
firstEncoderData = new byte[index];
|
secondSignData = new byte[len - index - 1];
|
//合并两个byte[]
|
System.arraycopy(sbytes, 0, firstEncoderData, 0, firstEncoderData.length);
|
System.arraycopy(sbytes, index + 1, secondSignData, 0, secondSignData.length);
|
//如果已经是base64编码， 则直接返回
|
if (isArrayByteBase64(secondSignData)) {
|
break;
|
}
|
}
|
}
|
String sign = new String(secondSignData);
|
|
boolean verify = RSADeCoder.verify(firstEncoderData, sign, publicKey);
|
if (!verify) {
|
throw new RuntimeException("License签名校验无效,请确认这证书的有效性.");
|
}
|
//再次解密， 得到最终的授权内容
|
byte[] textBytes = RSADeCoder.decryptRSA(firstEncoderData, publicKey);
|
System.out.println("授权文件详情:\n" + new String(textBytes));
|
HashMap<String, String> prop = genDataFromArrayByte(textBytes);
|
String licenseType = prop.get("LICENSETYPE");
|
System.out.println("授权软件给:\n" + prop.get("LICENSENAME"));
|
String machineCode = prop.get("MACHINECODE");
|
String needCheckMachineCode = prop.get("CHECKMACHINECODE");
|
if ((Boolean.TRUE.toString().equalsIgnoreCase(needCheckMachineCode))) {
|
//唯一机器码
|
String machCode = getSerialNumHDForLinux();
|
if (StringUtils.isEmpty(machineCode) || ("," + machineCode + ",").indexOf("," + machCode + ",") < 0) {
|
//--机器码的校验
|
throw new RuntimeException("License校验,机器码与当前机器码不同");
|
}
|
|
}
|
if ("2".equals(licenseType)) {
|
DateFormat df = new SimpleDateFormat("yyyy-MM-dd", Locale.ENGLISH);
|
String expireDay = prop.get("EXPIREDAY");
|
Date expireDate = df.parse(expireDay);
|
if (currentDate.after(expireDate)) {
|
throw new RuntimeException("License已经过期,请联系厂商重新获取License授权.");
|
}
|
}
|
return true;
|
|
}
|
|
/**
|
* 获取文件过期时间
|
*
|
* @param licenseFilePath 文件路径
|
* @return
|
* @throws Exception
|
*/
|
public static Date getLicenseExipreDate(String licenseFilePath) throws Exception {
|
// 加载证书
|
PublicKey publicKey = RSADeCoder.getPublicKey(CryptoPublicKeys.KEYMODULUS, CryptoPublicKeys.PUBLICKEYEXPONENT);
|
File licenseFile = new File(licenseFilePath);
|
if (!licenseFile.exists()) {
|
throw new Exception("没有获取License文件");
|
}
|
FileInputStream fis = FileUtils.openInputStream(licenseFile);
|
if (fis.available() == 0) {
|
throw new FileNotFoundException("License加密文件为空");
|
}
|
fis.close();
|
//首先读入License文件
|
byte[] encoderData = FileUtils.readFileToByteArray(licenseFile);
|
byte[] sbytes = RSADeCoder.decryptRSA(encoderData, publicKey);
|
byte[] firstEncoderData = null;
|
byte[] secondSignData = null;
|
int index = 0;
|
for (int len = sbytes.length; index < len; index++) {
|
if (sbytes[index] == '\n') {
|
firstEncoderData = new byte[index];
|
secondSignData = new byte[len - index - 1];
|
//合并两个byte[]
|
System.arraycopy(sbytes, 0, firstEncoderData, 0, firstEncoderData.length);
|
System.arraycopy(sbytes, index + 1, secondSignData, 0, secondSignData.length);
|
//如果已经是base64编码， 则直接返回
|
if (isArrayByteBase64(secondSignData)) {
|
break;
|
}
|
}
|
}
|
String sign = new String(secondSignData);
|
|
boolean verify = RSADeCoder.verify(firstEncoderData, sign, publicKey);
|
if (!verify) {
|
throw new RuntimeException("License签名校验无效,请确认这证书的有效性.");
|
}
|
//再次解密， 得到最终的授权内容
|
byte[] textBytes = RSADeCoder.decryptRSA(firstEncoderData, publicKey);
|
System.out.println("授权文件详情:\n" + new String(textBytes));
|
HashMap<String, String> prop = genDataFromArrayByte(textBytes);
|
String licenseType = prop.get("LICENSETYPE");
|
System.out.println("授权软件给:\n" + prop.get("LICENSENAME"));
|
String machineCode = prop.get("MACHINECODE");
|
String needCheckMachineCode = prop.get("CHECKMACHINECODE");
|
if ((Boolean.TRUE.toString().equalsIgnoreCase(needCheckMachineCode))) {
|
//唯一机器码
|
String machCode = getSerialNumHDForLinux();
|
if (StringUtils.isEmpty(machineCode) || ("," + machineCode + ",").indexOf("," + machCode + ",") < 0) {
|
//--机器码的校验
|
throw new RuntimeException("License校验,机器码与当前机器码不同");
|
}
|
|
}
|
if ("2".equals(licenseType)) {
|
DateFormat df = new SimpleDateFormat("yyyy-MM-dd", Locale.ENGLISH);
|
String expireDay = prop.get("EXPIREDAY");
|
Date expireDate = df.parse(expireDay);
|
return expireDate;
|
}
|
return null;
|
}
|
|
private static HashMap<String, String> genDataFromArrayByte(byte[] b) throws IOException {
|
BufferedReader br = new BufferedReader(new InputStreamReader(new ByteArrayInputStream(b)));
|
HashMap<String, String> data = new HashMap<String, String>();
|
String str = null;
|
while ((str = br.readLine()) != null) {
|
if (StringUtils.isNotEmpty(str)) {
|
str = str.trim();
|
int pos = str.indexOf("=");
|
if (pos <= 0) continue;
|
if (str.length() > pos + 1) {
|
data.put(str.substring(0, pos).trim().toUpperCase(), str.substring(pos + 1).trim());
|
} else {
|
data.put(str.substring(0, pos).trim().toUpperCase(), "");
|
}
|
}
|
}
|
return data;
|
}
|
|
private static boolean isArrayByteBase64(byte[] b) {
|
try {
|
if (Base64.isArrayByteBase64(b)) {
|
return true;
|
}
|
return false;
|
} catch (Exception e) {//nothing todo
|
return false;
|
}
|
}
|
|
/**
|
* 获取机器唯一码
|
*
|
* @return
|
* @throws IOException
|
*/
|
public static String getSerialNumHDForLinux() throws IOException {
|
String machineIdLinux = "";
|
String os = System.getProperty("os.name").toLowerCase();
|
if (os.contains("win")) {
|
return "";
|
}
|
try {
|
StringBuffer output = new StringBuffer();
|
|
Process p = Runtime.getRuntime().exec("/bin/bash -c\"hdparm -I /dev/sda | grep Serial\"");
|
BufferedReader sNumReader = new BufferedReader(new InputStreamReader(p.getInputStream()));
|
|
String line = "";
|
while ((line = sNumReader.readLine()) != null) {
|
output.append(line + "\n");
|
}
|
machineIdLinux = output.toString().substring(output.indexOf("\n"), output.length()).trim();
|
|
} catch (IOException e) {
|
e.getMessage();
|
throw e;
|
}
|
return machineIdLinux;
|
}
|
|
public static String[] convertLicenseDataToFileContent(LicenseData licenseData) {
|
List<String> contentList = new ArrayList<>();
|
|
if (licenseData.getLicenseId() != null) {
|
contentList.add("licenseId=" + licenseData.getLicenseId());
|
}
|
if (licenseData.getLicenseName() != null) {
|
contentList.add("licenseName=" + licenseData.getLicenseName());
|
}
|
if (licenseData.getLicenseType() != null) {
|
contentList.add("licenseType=" + licenseData.getLicenseType());
|
}
|
if (licenseData.getExpireDay() != null) {
|
contentList.add("expireDay=" + DateUtils.formatDate(licenseData.getExpireDay(), CommonConstant.YYYY_MM_DD)); // Using timestamp
|
}
|
if (licenseData.getPrintClientCount() != null) {
|
contentList.add("printClientCount=" + licenseData.getPrintClientCount());
|
}
|
if (licenseData.getCheckMachineCode() != null) {
|
contentList.add("checkMachineCode=" + licenseData.getCheckMachineCode());
|
}
|
if (licenseData.getMachineCode() != null && !licenseData.getMachineCode().isEmpty()) {
|
contentList.add("machineCode=" + String.join(",", licenseData.getMachineCode()));
|
}
|
|
return contentList.toArray(new String[0]);
|
}
|
|
}
|
