SpringBoot-Web 使用TrueLicense生成软件许可-client端

已于 2022-03-21 15:13:51 修改
阅读量2.9k 收藏 3
点赞数
文章标签： spring boot web安全 系统安全
于 2021-10-12 18:57:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Y_C_H/article/details/120729426
版权

客户端部署的应用中添加License校验

创建微服务项目名称： cloud-license-client，版本：2.5.5，模拟给客户部署的应用。

1.1pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.5</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- License -->
        <dependency>
            <groupId>de.schlichtherle.truelicense</groupId>
            <artifactId>truelicense-core</artifactId>
            <version>1.33</version>
        </dependency>

        <dependency>
            <groupId>net.sourceforge.nekohtml</groupId>
            <artifactId>nekohtml</artifactId>
            <version>1.9.18</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.7</version>
        </dependency>

        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.0.6</version>
        </dependency>


    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>

            <!--在这里修改版本-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <version>2.4.3</version>
            </plugin>
            <!---->

        </plugins>
    </build>


</project>

1.2 application.properties

server.port=8082

#启用优雅关机
server.shutdown=graceful
#缓冲10秒
spring.lifecycle.timeout-per-shutdown-phase=10s

#License相关配置
license.subject=license_demo
license.publicAlias=publicCert
license.storePass=public_password12345
license.licensePath=D:/workspace/gitee/spring-boot2-license/license/license.lic
license.publicKeysStorePath=D:/workspace/gitee/spring-boot2-license/license/publicCerts.keystore

json.class.type=jackson

1.3 License校验类

package com.example.license;


import com.example.entity.LicenseVerifyParam;
import com.example.helper.LoggerHelper;
import com.example.helper.ParamInitHelper;
import com.example.model.LicenseCustomManager;
import com.example.model.LicenseResult;
import com.example.utils.DateUtils;
import de.schlichtherle.license.*;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.ResourceUtils;

import java.io.File;
import java.text.DateFormat;
import java.text.MessageFormat;
import java.text.SimpleDateFormat;
import java.util.prefs.Preferences;


/**
 * @program: cloud-license-client
 * @description: License校验类
 * @author: xiaoyang
 * @create: 2021-10-11 10:37
 **/
@Slf4j
public class LicenseVerify {
    /**
     * 安装License证书
     */
    public synchronized LicenseContent install(LicenseVerifyParam param){
        LicenseContent result = null;
        DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        //1. 安装证书
        try{
            LicenseManager licenseManager = LicenseManagerHolder.getInstance(initLicenseParam(param));
            licenseManager.uninstall();

            result = licenseManager.install(new File(param.getLicensePath()));
            log.info(MessageFormat.format("证书安装成功，证书有效期：{0} - {1}",format.format(result.getNotBefore()),format.format(result.getNotAfter())));
        }catch (Exception e){
            log.error("证书安装失败！",e);
        }

        return result;
    }

    /**
     * 校验License证书
     * @return boolean
     */
    public boolean verify(LicenseVerifyParam param){
        LicenseManager licenseManager = LicenseManagerHolder.getInstance(initLicenseParam(param));
        DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        //2. 校验证书
        try {
            LicenseContent licenseContent = licenseManager.verify();
//            System.out.println(licenseContent.getSubject());

            log.info(MessageFormat.format("证书校验通过，证书有效期：{0} - {1}",format.format(licenseContent.getNotBefore()),format.format(licenseContent.getNotAfter())));
            return true;
        }catch (Exception e){
            log.error("证书校验失败！",e);
            return false;
        }
    }

    /**
     * 初始化证书生成参数
     * @param param License校验类需要的参数
     * @return de.schlichtherle.license.LicenseParam
     */
    private LicenseParam initLicenseParam(LicenseVerifyParam param){
        Preferences preferences = Preferences.userNodeForPackage(LicenseVerify.class);

        CipherParam cipherParam = new DefaultCipherParam(param.getStorePass());

        KeyStoreParam publicStoreParam = new CustomKeyStoreParam(LicenseVerify.class
                ,param.getPublicKeysStorePath()
                ,param.getPublicAlias()
                ,param.getStorePass()
                ,null);

        return new DefaultLicenseParam(param.getSubject()
                ,preferences
                ,publicStoreParam
                ,cipherParam);
    }

}

1.4 添加Listener，用于启动项目时安装License证书

package com.example.license;

import com.example.entity.LicenseVerifyParam;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.stereotype.Component;

/**
 * @program: cloud-license-client
 * @description: 在项目启动时安装证书
 * @author: xiaoyang
 * @create: 2021-10-11 10:40
 **/
@Slf4j
@Component
public class LicenseCheckListener implements ApplicationListener<ContextRefreshedEvent> {

    /**
     * 证书subject
     */
    @Value("${license.subject}")
    private String subject;

    /**
     * 公钥别称
     */
    @Value("${license.publicAlias}")
    private String publicAlias;

    /**
     * 访问公钥库的密码
     */
    @Value("${license.storePass}")
    private String storePass;

    /**
     * 证书生成路径
     */
    @Value("${license.licensePath}")
    private String licensePath;

    /**
     * 密钥库存储路径
     */
    @Value("${license.publicKeysStorePath}")
    private String publicKeysStorePath;

    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        //root application context 没有parent
        ApplicationContext context = event.getApplicationContext().getParent();
        if(context == null){
            if(StringUtils.isNotBlank(licensePath)){
                log.info("++++++++ 开始安装证书 ++++++++");

                LicenseVerifyParam param = new LicenseVerifyParam();
                param.setSubject(subject);
                param.setPublicAlias(publicAlias);
                param.setStorePass(storePass);
                param.setLicensePath(licensePath);
                param.setPublicKeysStorePath(publicKeysStorePath);

                LicenseVerify licenseVerify = new LicenseVerify();
                //安装证书
                licenseVerify.install(param);

                log.info("++++++++ 证书安装结束 ++++++++");
            }
        }
    }

    public  LicenseVerifyParam getVerifyParam(){
        LicenseVerifyParam param = new LicenseVerifyParam();
        param.setSubject(subject);
        param.setPublicAlias(publicAlias);
        param.setStorePass(storePass);
        param.setLicensePath(licensePath);
        param.setPublicKeysStorePath(publicKeysStorePath);
        return param;
    }
}

1.5 添加拦截器，用于在登录的时候校验License证书

package com.example.config;

import com.example.license.LicenseCheckInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.FilterType;
import org.springframework.web.servlet.config.annotation.*;

/**
 * @program: cloud-license-client
 * @description: 拦截器配置
 * @author: xiaoyang
 * @create: 2021-10-11 10:42
 **/

import org.springframework.context.annotation.Configuration;

/**
 * @Description: 拦截器配置
 */
@Configuration
@ComponentScan(basePackages = {"com.example"})
public class InterceptorConfig extends WebMvcConfigurationSupport {

    @Autowired
    public LicenseCheckInterceptor licenseCheckInterceptor;


    public InterceptorConfig() {
        System.out.println("============InterceptorConfig 已装载===========");
    }


    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/**").addResourceLocations("classpath:/static/");
        registry.addResourceHandler("swagger-ui.html")
                .addResourceLocations("classpath:/META-INF/resources/");
        registry.addResourceHandler("/webjars/**")
                .addResourceLocations("classpath:/META-INF/resources/webjars/");
        super.addResourceHandlers(registry);
    }


    @Override
    public void addInterceptors(InterceptorRegistry registry) {

        System.out.println("拦截中");

        //添加要拦截的url
        registry.addInterceptor(licenseCheckInterceptor)
                // 拦截的路径
                .addPathPatterns("/**");
        System.out.println("已拦截");
        // 放行的路径
//                .excludePathPatterns("/admin/login");
    }

}

1.6 创建LicenseManagerHolder类

package com.example.license;

import de.schlichtherle.license.LicenseManager;
import de.schlichtherle.license.LicenseParam;

/**
 * @program: cloud-license-client
 * @description:
 * @author: xiaoyang
 * @create: 2021-10-11 11:01
 **/
public class LicenseManagerHolder {

    private static LicenseManager licenseManager;

    public static synchronized LicenseManager getLicenseManager(LicenseParam licenseParam) {

        if(null == licenseManager) {

            try {

                licenseManager = new LicenseManager(licenseParam);

            } catch (Exception e) {

                e.printStackTrace();

            }

        }

        return licenseManager;

    }

    public static LicenseManager getInstance(LicenseParam initLicenseParam) {
        return new LicenseManager(initLicenseParam);
    }
}

1.7 创建LicenseVerifyParam类

package com.example.entity;

import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * @program: cloud-license-client
 * @description: License校验参数
 * @author: xiaoyang
 * @create: 2021-10-11 10:49
 **/

@Component
public class LicenseVerifyParam {


//    /**证书主题*/
//    private String subject;
//
//    /**公钥别名*/
//    private String publicAlias;
//
//    /** 访问公钥库的密码*/
//    private String storePass;
//
//    /**证书生成路径*/
//    private String licensePath;
//
//    /**公钥库存储路径*/
//    private String publicKeysStorePath;

    /**
     * 证书subject
     */
    @Value("${license.subject}")
    private String subject;

    /**
     * 公钥别称
     */
    @Value("${license.publicAlias}")
    private String publicAlias;

    /**
     * 访问公钥库的密码
     */
    @Value("${license.storePass}")
    private String storePass;

    /**
     * 证书生成路径
     */
    @Value("${license.licensePath}")
    private String licensePath;

    /**
     * 密钥库存储路径
     */
    @Value("${license.publicKeysStorePath}")
    private String publicKeysStorePath;

    public LicenseVerifyParam() {

    }

    public LicenseVerifyParam(String subject, String publicAlias, String storePass, String licensePath, String publicKeysStorePath) {
        this.subject = subject;
        this.publicAlias = publicAlias;
        this.storePass = storePass;
        this.licensePath = licensePath;
        this.publicKeysStorePath = publicKeysStorePath;
    }

    public String getSubject() {
        return subject;
    }

    public void setSubject(String subject) {
        this.subject = subject;
    }

    public String getPublicAlias() {
        return publicAlias;
    }

    public void setPublicAlias(String publicAlias) {
        this.publicAlias = publicAlias;
    }

    public String getStorePass() {
        return storePass;
    }

    public void setStorePass(String storePass) {
        this.storePass = storePass;
    }

    public String getLicensePath() {
        return licensePath;
    }

    public void setLicensePath(String licensePath) {
        this.licensePath = licensePath;
    }

    public String getPublicKeysStorePath() {
        return publicKeysStorePath;
    }

    public void setPublicKeysStorePath(String publicKeysStorePath) {
        this.publicKeysStorePath = publicKeysStorePath;
    }

    @Override
    public String toString() {
        return "LicenseVerifyParam{" +
                "subject='" + subject + '\'' +
                ", publicAlias='" + publicAlias + '\'' +
                ", storePass='" + storePass + '\'' +
                ", licensePath='" + licensePath + '\'' +
                ", publicKeysStorePath='" + publicKeysStorePath + '\'' +
                '}';
    }

    public LicenseVerifyParam getVerifyParam() {
        LicenseVerifyParam param = new LicenseVerifyParam();
        param.setSubject(subject);
        param.setPublicAlias(publicAlias);
        param.setStorePass(storePass);
        param.setLicensePath(licensePath);
        param.setPublicKeysStorePath(publicKeysStorePath);
        return param;
    }
}

1.8 创建CustomKeyStoreParam类

package com.example.license;

/**
 * @program: cloud-license-serve
 * @description: 自定义KeyStoreParam类
 * @author: xiaoyang
 * @create: 2021-10-11 09:21
 **/

import de.schlichtherle.license.AbstractKeyStoreParam;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

/**
 * 自定义KeyStoreParam，用于将公私钥存储文件存放到其他磁盘位置而不是项目中。现场使用的时候公钥大部分都不会放在项目中的
 */
public class CustomKeyStoreParam extends AbstractKeyStoreParam {

    /**
     * 公钥/私钥在磁盘上的存储路径
     */
    private String storePath;
    private String alias;
    private String storePwd;
    private String keyPwd;

    public CustomKeyStoreParam(Class clazz, String resource, String alias, String storePwd, String keyPwd) {
        super(clazz, resource);
        this.storePath = resource;
        this.alias = alias;
        this.storePwd = storePwd;
        this.keyPwd = keyPwd;
    }


    @Override
    public String getAlias() {
        return alias;
    }

    @Override
    public String getStorePwd() {
        return storePwd;
    }

    @Override
    public String getKeyPwd() {
        return keyPwd;
    }

    /**
     * AbstractKeyStoreParam里面的getStream()方法默认文件是存储的项目中。
     * 用于将公私钥存储文件存放到其他磁盘位置而不是项目中
     */
    @Override
    public InputStream getStream() throws IOException {
        return new FileInputStream(new File(storePath));
    }
}

创建FastLicense 自定义注解

package com.example.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface FastLicense {

    String[] verifies() default{};

}

1.9 创建Controller模拟登录操作

package com.example.controller;

import com.example.annotation.FastLicense;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.text.MessageFormat;
import java.util.HashMap;
import java.util.Map;

/**
 * @program: cloud-license-client
 * @description: 模拟登录
 * @author: xiaoyang
 * @create: 2021-10-11 11:10
 **/

@Slf4j
@CrossOrigin
@RestController
public class LoginController {

    /**
     * 模拟登录验证
     * @param loginName 用户名
     * @param password 密码
     */
    @GetMapping(value = "/login")
    @FastLicense
    public Map<String,Object> test(@RequestParam(required = true) String loginName, @RequestParam(required = true) String password){
        Map<String,Object> result = new HashMap<>(1);
        log.info(MessageFormat.format("登录名称：{0}，密码：{1}",loginName,password));
        //模拟登录
        log.info("模拟登录被拦截检查证书可用性");
        result.put("code",200);
        return result;
    }
}

模拟安装证书失败
在这里插入图片描述
在这里插入图片描述

安装证书成功
在这里插入图片描述
在这里插入图片描述

小羊太懒了
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
springboot+spring security给web应用增加权限验证的若干难题
大头哥的哥
01-14 465
1.Refused to execute script from '....js' because its MIME type ('text/html') is not executable... 引用博客：https://blog.csdn.net/c4jem/article/details/77131422 该问题是因为加了权限验证导致默认不需要权限验证的静态文件例如css js等也被拦...
SpringBoot-Eureka-xstream-rce漏洞复现
tpaer的博客
11-25 9161
关于SpringBoot-Eureka-xstream-rce漏洞复现的一次实战。
SpringBoot整合TrueLicense实现License的授权与服务器许可
xmt1139057136的专栏
08-22 6032
你知道的越多，不知道的就越多，业余的像一棵小草！你来，我们一起精进！你不来，我和你的竞争对手一起精进！编辑：业余草来源：juejin.im/post/685457321142675047...
SpringBoot 整合 TrueLicense 实现 License 的授权与服务器许可1
08-03
前言License，即版权许可证，一般用于收费软件给付费用户提供的访问许可证明。根据应用部署位置的不同，一般可以分为以下两种情况讨论：应用部署在开发者自己的云服
springboot基于license详细实践
yangfenggh的博客
03-12 5936
package cn.zifangsky.license; import java.io.Serializable; import java.util.List; /** * 自定义需要校验的License参数 * * @author zifangsky * @date 2018/4/23 * @since 1.0.0 */ public class LicenseCheckModel implements Serializable{ private static final
基于springboot项目License的生成和验证
Lonels的博客
10-21 1882
1 .使用JDK自带的 keytool 工具生成公私钥证书库,私钥用于生成License文件,公钥用于验证License文件,我这里只是给一个时间验证,证书的过期时间 生成证书接口 Controller层 @RequestMapping(value = "/generateLicense",produces = {MediaType.APPLICATION_JSON_UTF8_VALUE}) public Map<String,Object> generateLicense(@Requ
wsdl2java源码-springboot-apachecxf-client:本项目演示了如何在Springboot中实现apachecxf
06-05
wsdl2java源码springboot-apachecxf-client 本项目演示了如何在Springboot中实现apachecxf客户端，以及如何为客户端调用生成wsdltojava。 Springboot-apachecxf-jaxws 示例 此应用程序展示了如何使用 apachecxf ...
springboot-casclient.rar
08-02
本项目"springboot-casclient"旨在展示如何将SpringBoot与CAS相结合，实现单点登录，并结合Thymeleaf模板引擎和Shiro权限管理，构建一个完整的安全认证与授权解决方案。 首先，我们来深入理解SpringBoot集成CAS的...
springboot-keycloak-bearer-only-demo
05-10
这是一个简单的演示，描述了如何在REST Web应用程序中将Keycloak与Spring Boot一起使用。 客户端的访问类型“ app1”是仅承载。 您必须将访问令牌与请求一起传递，以访问API。 您必须提供client_id，用户名，密码，...
springboot-oauth2-server：一个简单的Oauth2服务器，它使用springboot配置了JWT
02-19
在SpringBoot中，我们可以使用`JwtAccessTokenConverter`和`JwtTokenStore`来处理JWT的生成和验证。 项目`springboot-oauth2-server-master`中的代码示例展示了如何配置这些组件。它包括了OAuth2的授权端点、令牌...
使用truelicense实现用于JAVA工程license机制（包括license生成和验证）
04-03
使用truelicense实现用于JAVA工程license机制（包括license生成和验证）
Spring Boot项目中使用 TrueLicense 生成和验证License（服务器许可）
weixin_34111790的博客
07-11 1443
一 简介 License，即版权许可证，一般用于收费软件给付费用户提供的访问许可证明。根据应用部署位置的不同，一般可以分为以下两种情况讨论： 应用部署在开发者自己的云服务器上。这种情况下用户通过账号登录的形式远程访问，因此只需要在账号登录的时候校验目标账号的有效期、访问权限等信息即可。 应用部署在客户的内网环境。因为这种情况开发者无法控制客户的网络环境，也不能保证应用所在服务器可以访问外网，因此...
TrueLicense实现权限认证功能
编程农民工的博客
01-06 189
【代码】TrueLicense实现权限认证功能。
Springboot 添加License 以及生成证书和证书验证
最新发布
a50395967的博客
04-10 2178
storepass：指定私钥库的密码(获取keystore信息所需的密码)# keystore: 指定私钥库文件的名称(生成在当前目录)# keystore：指定私钥库的名称(在当前目录查找)# keypass：指定别名条目的密码(私钥的密码)# storepass: 指定私钥库的密码。# validity：私钥的有效期多少天。# storepass：指定私钥库的密码。# keystore：公钥文件名称。# alias：私钥别称。# alias：私钥别称。# file：证书名称。
Spring Boot2 使用 License 实现系统软件版权许可认证
lovelichao12的专栏
05-14 7061
一License 简介 License即版权许可证，一般用于收费软件给付费用户提供的访问许可证明。根据应用部署位置的不同，一般可以分为以下两种情况讨论： 应用部署在开发者自己的云服务器上。这种情况下用户通过账号登录的形式远程访问，因此只需要在账号登录的时候校验目标账号的有效期、访问权限等信息即可。 应用部署在客户的内网环境。因为这种情况开发者无法控制客户的网络环境，也不能保证应用所在服务器可以访问外网，因此通常的做法是使用服务器许可文件，在客户应用启动的时候加载证书，然后在登录或者其他关键操作的地方.
springboot整合truelicense，添加项目许可证书，支持动态扩展
qq_36382225的博客
10-29 1673
使用方法 生成publicCerts.keystore ### license生成证书命令，JDK自带keytool工具 #生成：在当前目录下，生成一个名为privateKeys.keystore的密钥库，同时指定密钥库密码为public_password1234，第一个条目为privateKey，指定条目密码为private_password1234 keytool -genkeypair -keysize 1024 -validity 1 -alias "privateKey" -keystor
SpringBoot -- 软件许可（License）证书生成+验证+应用完整流程
热门推荐
Appleyk的专栏
09-27 14万+
一、项目目录树结构 由于时间有限，不可能在博客上花太多时间、也不可能每一个细节都说的很细，所以，下面的内容虽然一时间看着比较懵，但是文末有项目的GitHub地址，或者不懂的可以留言； 这个是粗糙的项目结构，没有细分，实际应用的话应该是授权的代码要和验证的代码分开，防止授权的代码引进客户端系统中，被破解和拆穿，也为了防止公钥st...
TrueLicense源码解析-寻找docker中使用license安装后存放的位置
MyfishCake的博客
08-19 1517
springBoot调用TrueLicense生成证书，根据源码寻找证书安装文件位置，Windows操作系统
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小羊太懒了

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值