springboot整合License授权控制

已于 2024-11-20 09:13:34 修改
阅读量343 收藏
点赞数 3
文章标签： java spring boot
于 2024-11-19 11:39:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_45317823/article/details/143878021
版权

yml配置文件设置读取licenses文件位置 

license:
  filePath: "D://licenses.lc"

 创建licenses文件码


import sun.misc.BASE64Encoder;

import java.security.MessageDigest;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 许可文件的生成类<br>
 * 只用于在公司内网生成许可文件，不得出公司内网、更不得打包到项目中
 * @author lidaquan
 *
 */
public class LicenseMaker {

    private static final String TYPE_DATE = "date";

    private static final String TYPE_DATE_DW = "date_hw";

    private static final String OS_WINDOWS = "Windows";

    private static final String OS_LINUX = "Linux";

    private static final String OS_AIX = "AIX";

    private static final String FAKE_MAC = "abcdef123456";

    /**
     *
     * @param type
     * @param endDay
     * @param osArray 如果macAddressArray不为空，则osArray与macAddressArray的个数必须相同
     * @param macAddressArray 单实例环境与单机集群环境均为一个，多机集群环境为多个；不管什么环境，对于每台机器应该只允许一个；出于保护目的，目前最多允许4个；如果不是基于硬件的许可，可以设为null
     * @param serie 从技术上控制可以使用该许可的项目类别（可以达到强制控制的目的，但无法细化到具体项目或用户）
     * @param user  从字面上声明可以使用该许可的项目名称或用户名称（无法达到强制控制的目的，但可以细化到具体项目或用户）
     */
    public static void create(String type, String endDay, String[] osArray, String[] macAddressArray, String serie, String user){
        String osSet = "";
        String macAddressSet = "";
        if(type == null || "".equals(type) || endDay == null || "".equals(endDay) || osArray == null || osArray.length == 0 || serie == null || "".equals(serie) || user == null || "".equals(user)){
            throw new IllegalArgumentException("参数不能为空");
        }else if(TYPE_DATE_DW.equals(type)){
//            if(macAddressArray == null || macAddressArray.length == 0){
//                throw new IllegalArgumentException("参数不能为空");
//            }
//            if(macAddressArray.length > 4){
//                throw new IllegalArgumentException("参数超过上限");
//            }
//            if(osArray.length != macAddressArray.length){
//                throw new IllegalArgumentException("osArray与macAddressArray的数量不一致");
//            }
            for(int i = 0, size = osArray.length;i < size;i++){
                String os = osArray[i];
                if(os == null || "".equals(os)){
                    throw new IllegalArgumentException("参数不能为空");
                }
//                String macAddress = macAddressArray[i];
//                if(macAddress == null || "".equals(macAddress) || macAddress.length() != 12){
//                    throw new IllegalArgumentException("参数不能为空并且长度必须为12位");
//                }
                osSet += os;
//                macAddressSet += macAddress;
                if(i < size - 1){
                    osSet += "_";
//                    macAddressSet += "_";
                }
            }
        }else if(TYPE_DATE.equals(type)){
            if(osArray.length > 1){
                throw new IllegalArgumentException("参数超过上限");
            }
            osSet = osArray[0];
        }
        try{
            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
            Date endDate = dateFormat.parse(endDay);
            Date now = new Date();
            Date authDate = new Date(now.getYear(), now.getMonth(), now.getDate());

            System.out.println("许可颁发类型：" + type);
            System.out.println("许可结束日期：" + dateFormat.format(endDate));
            System.out.println("许可颁发日期：" + dateFormat.format(authDate));
            System.out.println("许可适用系统：" + osSet);
            System.out.println("许可颁发网卡：" + macAddressSet);
            System.out.println("许可颁发产品：" + serie);
            System.out.println("许可颁发用户：" + user);
            System.out.println("---------------------------------------------------------------");

            MessageDigest md = MessageDigest.getInstance("SHA-1");
            System.out.print("serial=");
            System.out.print(encode(type));
            md.update(type.getBytes());
            byte[] degist = md.digest();
            System.out.print("-" + new BASE64Encoder().encode(degist));

            String endDateStr = dateFormat.format(endDate);
            System.out.print("-" + encode(endDateStr));
            md.update(endDateStr.getBytes());
            degist = md.digest();
            System.out.print("-" + new BASE64Encoder().encode(degist));

            String authDateStr = dateFormat.format(authDate);
            System.out.print("-" + encode(authDateStr));
            md.update(authDateStr.getBytes());
            degist = md.digest();
            System.out.print("-" + new BASE64Encoder().encode(degist));

            System.out.print("-" + encode(osSet));
            md.update(osSet.getBytes());
            degist = md.digest();
            System.out.print("-" + new BASE64Encoder().encode(degist));

            if(TYPE_DATE.equals(type)){
                macAddressSet = FAKE_MAC;
            }else{
                macAddressSet = macAddressSet.toLowerCase();
            }
            System.out.print("-" + encode(macAddressSet));
            md.update(macAddressSet.getBytes());
            degist = md.digest();
            System.out.print("-" + new BASE64Encoder().encode(degist));

            System.out.print("-" + encode(serie));
            md.update(serie.getBytes());
            degist = md.digest();
            System.out.print("-" + new BASE64Encoder().encode(degist));

            System.out.print("-" + encode(user));
            md.update(user.getBytes());
            degist = md.digest();
            System.out.print("-" + new BASE64Encoder().encode(degist));

        }catch(Exception e){
            e.printStackTrace();
        }
    }

    private static String encode(String msg){
        byte[] code = msg.getBytes();
        exchangeCode(code);
        BASE64Encoder encoder = new BASE64Encoder();
        return encoder.encode(code);
    }

    private static void exchangeCode(byte[] code){
        int i, iSize;
        iSize = code.length/8;
        for (i = 0;i < iSize;i++){
            exchange(code, i*8 + 7, i*8);
            exchange(code, i*8 + 5, i*8 + 2);
        }
    }

    private static void exchange(byte[] code, int i, int j){
        byte temp = code[i];
        code[i] = code[j];
        code[j] = temp;
    }

    public static void main(String[] args){
       
        create(TYPE_DATE_DW, "2025-02-04", new String[]{OS_LINUX, OS_WINDOWS}, new String[]{}, "appName", "appChineseName");
    }

}


/**
 * ${appName}的许可标识<br>
 * 只允许用于${appName}的项目
 *
 */
public class LicenseChecker_appName extends LicenseChecker {

	public static final String SERIE = "appName";

	@Override
	protected String getSerie() {

		return SERIE;
	}

}

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

import java.net.NetworkInterface;
import java.security.MessageDigest;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Enumeration;

/**
 * 许可文件的校验类<br>
 * 随同许可文件打包到项目中
 *
 * @author bo a bo
 */
public abstract class LicenseChecker {

    public boolean check() {
        boolean valid = false;
        try {
            String serial = ReadLicenseUtils.readLicense();
            if (StringUtil.isEmpty(serial)) {
                throw new RuntimeException();// 未读取到license
            }
            MessageDigest md = MessageDigest.getInstance("SHA-1");
            String type = decode(serial.split("-")[0]);
            md.update(type.getBytes());
            String degistStr = new BASE64Encoder().encode(md.digest());
            if (!serial.split("-")[1].equals(degistStr)) {
                throw new RuntimeException();//许可颁发类型的序列号摘要不对
            }

            String endDateStr = decode(serial.split("-")[2]);
            md.update(endDateStr.getBytes());
            degistStr = new BASE64Encoder().encode(md.digest());
            if (!serial.split("-")[3].equals(degistStr)) {
                throw new RuntimeException();//许可结束日期的序列号摘要不对
            }

            String authDateStr = decode(serial.split("-")[4]);
            md.update(authDateStr.getBytes());
            degistStr = new BASE64Encoder().encode(md.digest());
            if (!serial.split("-")[5].equals(degistStr)) {
                throw new RuntimeException();//许可颁发日期的序列号摘要不对
            }

            String osSet = decode(serial.split("-")[6]);
            md.update(osSet.getBytes());
            degistStr = new BASE64Encoder().encode(md.digest());
            if (!serial.split("-")[7].equals(degistStr)) {
                throw new RuntimeException();//许可适用系统的序列号摘要不对
            }

            String hwSet = decode(serial.split("-")[8]);
            md.update(hwSet.getBytes());
            degistStr = new BASE64Encoder().encode(md.digest());
            if (!serial.split("-")[9].equals(degistStr)) {
                throw new RuntimeException();//许可颁发网卡的序列号摘要不对
            }

            String serie = decode(serial.split("-")[10]);
            md.update(serie.getBytes());
            degistStr = new BASE64Encoder().encode(md.digest());
            if (!serial.split("-")[11].equals(degistStr)) {
                throw new RuntimeException();//许可颁发产品的序列号摘要不对
            }

            String user = decode(serial.split("-")[12]);
            md.update(user.getBytes());
            degistStr = new BASE64Encoder().encode(md.digest());
            if (!serial.split("-")[13].equals(degistStr)) {
                throw new RuntimeException();//许可颁发用户的序列号摘要不对
            }

            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
            Date endDate = dateFormat.parse(endDateStr);
            Date authDate = dateFormat.parse(authDateStr);
            Date now = new Date();
            Date today = new Date(now.getYear(), now.getMonth(), now.getDate());
            if (endDate.compareTo(today) >= 0 && authDate.compareTo(today) <= 0 && this.getSerie().equals(serie)) {
                if ("date".equals(type) && System.getProperty("os.name").startsWith(osSet)) {
                    valid = true;
                }/*else if("devel".equals(user)){//这个分支用于方便开发人员在本地进行开发“绑定硬件的许可类型”的项目；只在项目工程的 WEB-INF\lib\ 目录下使用，在SVN上一定要注释掉（避免此分支出现在非本地开发环境）！！！
					valid = true;
				}*/ else {
                    String[] osArray = osSet.split("_");
                    if (!StringUtil.isEmpty(hwSet)) {
                        String[] hwArray = hwSet.split("_");
                        Enumeration<NetworkInterface> niel = NetworkInterface.getNetworkInterfaces();
                        allNetworkInterface:
                        while (niel.hasMoreElements()) {
                            NetworkInterface ni = niel.nextElement();
                            byte[] mac = ni.getHardwareAddress();
                            if (mac == null || mac.length != 6) {
                                continue;
                            }
                            StringBuffer macBuffer = new StringBuffer();
                            for (int i = 0, size = mac.length; i < size; i++) {
                                String s = "0" + Integer.toHexString(mac[i]);
                                s = s.substring(s.length() - 2);
                                macBuffer.append(s);
                            }
                            for (int i = 0; i < hwArray.length; i++) {
                                String hw = hwArray[i];
                                String os = osArray[i];
                                if (macBuffer.toString().equals(hw) && System.getProperty("os.name").startsWith(os)) {
                                    valid = true;
                                    break allNetworkInterface;
                                }
                            }
                        }
                    } else {
                        for (int i = 0; i < osArray.length; i++) {
                            String os = osArray[i];
                            if (System.getProperty("os.name").startsWith(os)) {
                                valid = true;
                                break;
                            }
                        }
                    }
                }
            }
        } catch (Exception e) {
        }
        return valid;
    }

    protected abstract String getSerie();

    private static String decode(String dec) {
        try {
            BASE64Decoder decoder = new BASE64Decoder();
            byte[] code = decoder.decodeBuffer(dec);
            vexchangeCode(code);
            return new String(code);
        } catch (Exception ex) {
            ex.printStackTrace();
            return null;
        }
    }

    private static void vexchangeCode(byte[] code) {
        int i, iSize;
        iSize = code.length / 8;
        for (i = 0; i < iSize; i++) {
            exchange(code, i * 8 + 2, i * 8 + 5);
            exchange(code, i * 8, i * 8 + 7);
        }
    }

    private static void exchange(byte[] code, int i, int j) {
        byte temp = code[i];
        code[i] = code[j];
        code[j] = temp;
    }

}


import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

import java.util.List;

/**
 * @author bo a bo
 */
@Data
@Component
@ConfigurationProperties(value = "license")
public class LicenseProperties {

    private String filePath;

    private String value;

    /**
     * 是否开启全局拦截,默认开启
     */
    private Boolean enabled = Boolean.TRUE;

    /**
     * 当不开启全局拦截时,需要配置哪些url需要拦截
     */
    private List<String> urlList;

}

import cn.hutool.core.io.FileUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.extra.spring.SpringUtil;

import java.io.FileNotFoundException;
import java.io.InputStream;
import java.io.RandomAccessFile;
import java.nio.charset.StandardCharsets;
import java.util.Properties;

public class ReadLicenseUtils {

    private static final String licenseFile = "licenses.lc";//在AIX7.1中，文件名必须加后缀，否则无法读取

    public static String readLicense() {
        LicenseProperties licenseProperties = null;
        try {
            licenseProperties = SpringUtil.getBean(LicenseProperties.class);
        } catch (Exception e) {
            licenseProperties = new LicenseProperties();
        }
        String filePath = licenseProperties.getFilePath();
        String license = null;
        if (FileUtil.exist(filePath)) {
            // 当配置的文件存在时，读取文件中的license
            try {
                license = FileUtil.readLine(new RandomAccessFile(filePath, "r"), StandardCharsets.UTF_8);
            } catch (FileNotFoundException e) {
                throw new RuntimeException(e);
            }
        }
        if (StrUtil.isNotBlank(license)) {
            return license;
        }
        // 当文件不存在，获取读取内容为空时，使用配置中的licesne
        license = licenseProperties.getValue();
        if (StrUtil.isNotBlank(license)) {
            return license;
        }
//        license = ResourceUtil.readStr(licenseFile, StandardCharsets.UTF_8);
//        if (StrUtil.isNotBlank(license)) {
//            return license;
//        }
//        license = ResourceUtil.readStr("/" + licenseFile, StandardCharsets.UTF_8);
//        if (StrUtil.isNotBlank(license)) {
//            return license;
//        }
//        return null;
        // 当配置中的license为空时，读取resources中的licenses.lc文件中的license
        InputStream is = null;
        try {
            Properties prop = new Properties();
            ClassLoader classLoader = ReadLicenseUtils.class.getClassLoader();
            is = classLoader.getResourceAsStream("/" + licenseFile);//某些JDK、中间件要加“/”
            if (is == null || is.available() == 0) {
                is = classLoader.getResourceAsStream(licenseFile);//某些JDK、中间件不加“/”
            }
            prop.load(is);
            String serial = prop.getProperty("serial");
            return serial;
        } catch (Exception e) {
        } finally {
            if (is != null) {
                try {
                    is.close();
                } catch (Exception e) {
                }
            }
        }
        return null;
    }

}

/**
 * 字符串工具类
 * @author bo a bo
 *
 */
public class StringUtil {

	/**
	 * 字符串是否为空（null、空串、空格、"null"）
	 * @param s
	 * @return
	 */
	public static boolean isEmpty(String s){
		if(s == null || "".equals(s.trim()) || "null".equalsIgnoreCase(s.trim())){
			return true;
		}
		return false;
	}

}

博哥哥گ
关注
Springboot集成License
uncle_wang_nb的博客
06-07 1693
springboot集成license授权项目管理
SpringBoot实现 License 认证（只校验有效期）
紫水木鱼的博客
10-25 1368
系统许可，
Spring Boot 项目集成 License 授权与续期完整指南
最新发布
weixin_38804310的博客
04-07 668
组件，可以快速实现系统权限到期控制、License 证书管理等功能。本文详细介绍如何集成 License 功能，并解决证书安装、权限配置、异常拦截及续期流程等关键问题。通过本文，您可以快速完成 License 组件的集成、权限配置和续期管理。：确保使用相同的密钥库（Keystore）生成新证书。支持证书安装、有效期校验、异常拦截。填写新证书的有效期和绑定信息，生成。异常，及时处理证书过期或非法操作。接口访问权限，支持证书状态查询。：新证书的密钥对与旧证书不匹配。：License 证书文件。
SpringBoot集成License
闲余知道
06-21 1459
SpringBoot集成License
SpringBoot 整合 TrueLicense 实现 License 的授权与服务器许可1
08-03
前言License，即版权许可证，一般用于收费软件给付费用户提供的访问许可证明。根据应用部署位置的不同，一般可以分为以下两种情况讨论：应用部署在开发者自己的云服
SpringBoot 整合 TrueLicense 实现 License 的授权与服务器许可.zip
08-20
项目工程资源经过严格测试可直接运行成功且功能正常的情况才上传，可轻松copy复刻，拿到资料包后可轻松复现出一样的项目，本人系统开发经验充足（全栈开发），有任何使用问题欢迎随时与我联系，我会及时为您解惑，...
基于SpringBoot校验license
11-27
总的来说，"基于SpringBoot校验license"项目提供了一个全面的许可管理系统模板，它涵盖了多种常见的许可验证方式，适用于那些希望加强软件安全性并有效控制使用权限的开发者。通过学习和理解这个项目，开发者不仅...
springboot 整合license
12-31
### 如何在 Spring Boot 中整合 License 模块实现授权管理 为了实现在 Spring Boot 项目中集成 license 模块并实现授权管理，可以按照以下方法操作： #### 创建 License 工程结构 首先创建一个新的 Maven 或 ...
java web springboot License生成器 (JAVA源码+图形界面)
09-23
保证java web ,spirngboot,tomcate web安全，可以现在IP，mac,自定义参数，License生成器 (JAVA源码+界面） 其中包括license授权机制的原理和制作license的具体步骤 增加了mac 地址验证
SpringBoot实现License认证（只校验有效期）
从基础到源码解析的学习记录
04-08 8157
License也就是版权许可证书，一般用于收费软件给付费用户提供的访问许可证明应用场景应用部署在客户的内网环境这种情况开发者无法控制客户的网络环境，也不能保证应用所在服务器可以访问外网因此通常的做法是使用服务器许可文件，在应用启动的时候加载证书然后在登录或者其他关键操作的地方校验证书的有效性License授权原理使用开源的证书管理引擎生成密钥对，使用Keytool生成公私钥证书库授权者保留私钥，使用私钥和使用日期生成证书license。
springboot实现web系统Licence验证
08-07
教程请见https://blog.youkuaiyun.com/Lammonpeter/article/details/78602862
SpringBoot -- 软件许可（License）证书生成+验证+应用完整流程
热门推荐
Appleyk的专栏
09-27 14万+
一、项目目录树结构 由于时间有限，不可能在博客上花太多时间、也不可能每一个细节都说的很细，所以，下面的内容虽然一时间看着比较懵，但是文末有项目的GitHub地址，或者不懂的可以留言； 这个是粗糙的项目结构，没有细分，实际应用的话应该是授权的代码要和验证的代码分开，防止授权的代码引进客户端系统中，被破解和拆穿，也为了防止公钥st...
spring boot添加License（软件许可）
MoLi的博客
05-27 1978
工作需要给软件加上许可。
eclipse spring boot项目搭建_spring-boot-plus项目打包(七)
weixin_39695374的博客
11-26 134
spring-boot-plus项目打包https://github.com/geekidea/spring-boot-plushttps://github.com/geekidea/spring-boot-plus 项目打包spring-boot-plus项目使用maven assembly插件进行打包根据不同环境进行打包部署包含启动、重启命令，配置文件提取到外部config目录 打包命令 ``...
springboot实现Web系统License授权认证
月月鸟先森的博客
07-29 3万+
在我们做系统级框架的时候，我们要一定程度上考虑系统的使用版权，不能随便一个人拿去在任何环境都能用，所以我们需要给我们系统做一个授权认证机制，只有上传了我们下发的lic文件并验证通过，才能正常使用，下面就开始一步一步实现这个功能 1.生成机器码 我们首先要做的就是对软件部署的环境的唯一性进行限制，这里使用的是macadderss，当然你也可以换成cpu序列编号，并无太大影响，先上代码 pri...
springboot项目授权许可
qq_43146871的博客
08-24 1202
使用smart-license1.0.3，给pringboot请求加载拦截器，用于商业许可授权，软件试用。
SpringBoot整合License实现认证
Joker_DJ
04-05 9100
SpringBoot整合License实现认证简介使用 TrueLicense 生成License创建maven工程导入pom依赖校验自定义的License参数License生成类需要的参数：添加抽象类AbstractServerInfos，用户获取服务器的硬件信息：获取客户Linux服务器的基本信息：获取客户Windows服务器的基本信息自定义LicenseManager，用于增加额外的服务器硬件信息校验License生成类，用于生成License证书自定义KeyStoreParam，用于将公私钥存储文件
springboot 实现license授权
04-27
Spring Boot 可以通过以下步骤实现 License 授权： 1. 在项目中创建 License 相关的文件夹和文件，如 config/license 文件夹和 license.lic 文件。 2. 在 pom.xml 文件中添加对于 jasypt 的依赖，用来加密和解密 License。 3. 创建一个 LicenseService 类，用来验证和解析 License。 4. 在应用程序启动时，读取 license.lic 文件，并将其内容解密和解析成 License 对象。 5. 在 LicenseService 类中实现验证和解析 License 的方法，同时在应用程序中使用 LicenseService 验证 License 的有效性。 6. 当 License 失效时，应用程序应该有相应的处理机制，如停止服务或限制服务功能。 这里需要注意的是，License 授权的实现需要根据具体业务场景进行调整，上述步骤只是一个大概的流程。同时，需要保证 License 信息的安全性，避免信息泄露和篡改。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值