双向认证的证书加密请求https站点

已于 2022-09-28 17:18:14 修改
阅读量227 收藏
点赞数
文章标签： https java servlet
于 2022-09-28 16:56:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_34903543/article/details/127092836
版权

maven

        <!-- https 双向认证 -->
        <dependency>
            <groupId>io.github.hakky54</groupId>
            <artifactId>sslcontext-kickstart-for-pem</artifactId>
            <version>5.3.0</version>
        </dependency>

代码

package com.cfnoc.ts.utils;

import com.cfnoc.ts.config.FilePathConfig;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.bouncycastle.asn1.pkcs.RSAPrivateKey;
import org.bouncycastle.util.io.pem.PemObject;
import org.bouncycastle.util.io.pem.PemReader;
import org.springframework.util.Assert;

import javax.net.ssl.*;
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.security.KeyFactory;
import java.security.KeyStore;
import java.security.PrivateKey;
import java.security.SecureRandom;
import java.security.cert.Certificate;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.RSAPrivateKeySpec;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;


@Slf4j
public class HttpsSslUtils {

    private static final int CONNECT_TIMEOUT_MILLES = 3000;
    private static final Charset ENCODING;
    private static final String HTTP_GET = "GET";
    private static final String HTTP_POST = "POST";
    private static final String[] METHODS;


    static {
        ENCODING = StandardCharsets.UTF_8;
        METHODS = new String[]{HTTP_GET, HTTP_POST};
    }

    public static String doSslGet(String url, Map<String, String> headers, Map<String, String> params, String content, SSLKeyStore ssl) throws Exception {
        return doOutput(url, HTTP_GET, headers, params, content, true, ssl);
    }

    public static String doSslPost(String url, Map<String, String> headers, Map<String, String> params, String content, SSLKeyStore ssl) throws Exception {
        return doOutput(url, HTTP_POST, headers, params, content, true, ssl);
    }

    private static String doOutput(final String url, final String method, final Map<String, String> headers, final Map<String, String> params, final String content, boolean isSsl, SSLKeyStore ssl) throws Exception {
        HttpURLConnection conn = null;
        try {
            conn = createConnection(setParams(url, params), isSsl, ssl);
            setMethod(conn, method);
            setHeaders(conn, headers);
            conn.connect();
            output(conn, content);
            return input(conn);
        } catch (Exception e) {
            throw e;
        } finally {
            connClose(conn);
        }
    }

    private static void connClose(HttpURLConnection conn) {
        if (conn != null) {
            conn.disconnect();
        }
    }

    private static String input(HttpURLConnection conn) throws IOException {
        int len;
        char[] cbuf = new char[1024 * 8];
        StringBuilder buf = new StringBuilder();
        int status = conn.getResponseCode();

        InputStream in = null;
        BufferedReader reader = null;
        try {
            in = conn.getErrorStream();
            if (in == null && status < 400) {
                //400或以上表示：访问的页面域名不存在或者请求错误、服务端异常
                in = conn.getInputStream();
            }
            if (in != null) {
                reader = new BufferedReader(new InputStreamReader(in, ENCODING));
                while ((len = reader.read(cbuf)) > 0) {
                    buf.append(cbuf, 0, len);
                }
            }
        } finally {
            if (reader != null) {
                reader.close();
            }
            if (in != null) {
                in.close();
            }
        }
        return buf.toString();
    }

    private static void output(HttpURLConnection conn, String content) throws IOException {
        if (StringUtils.isBlank(content)) {
            return;
        }
        OutputStream out = conn.getOutputStream();
        try {
            out.write(content.getBytes(ENCODING));
        } finally {
            if (out != null) {
                out.flush();
                out.close();
            }
        }
    }

    private static HttpsURLConnection createConnection(String url, boolean isSsl, SSLKeyStore ssl) throws Exception {
        HttpsURLConnection conn;
        if (isSsl) {
            try {
                conn = (HttpsURLConnection) (new URL(url)).openConnection();
                if (ssl != null) {
                    //ssl协议，证书验证
                    SSLSocketFactory sslSocketFactory = getSSLSocketFactory(ssl.getCaAlias(), ssl.getCaPath(), ssl.getCrtAlias(), ssl.getCrtPath(), ssl.getKeyPath(), ssl.getPassword());
                    conn.setSSLSocketFactory(sslSocketFactory);
                } else {
                    //ssl协议，跳过证书验证
                    httpssl(conn);
                }
            } catch (Exception e) {
                throw e;
            }
        } else {
            conn = (HttpsURLConnection) (new URL(url)).openConnection();
        }
        assert conn != null;
        setConfig(conn);
        return conn;
    }

    private static void setMethod(HttpURLConnection conn, String method) throws IOException {
        Assert.isTrue(StringUtils.containsAny(method, METHODS), "只支持GET、POST、PUT、DELETE操作");
        conn.setRequestMethod(method);
    }

    private static void setConfig(HttpURLConnection conn) {
        conn.setConnectTimeout(CONNECT_TIMEOUT_MILLES);
        conn.setUseCaches(false);
        conn.setInstanceFollowRedirects(true);
        conn.setRequestProperty("Connection", "close");
        //这个根据需求，自已加，也可以放到headersc参数内
        conn.setRequestProperty("Content-Type", "application/json; charset=UTF-8");
        //是否启用输出流，method=get,请求参数是拼接在地址档，默认为false
        conn.setDoOutput(true);
        //是否启用输入流
        conn.setDoInput(true);
    }

    private static void setHeaders(HttpURLConnection conn, Map<String, String> headers) {
        if (headers == null || headers.size() <= 0) {
            return;
        }
        //设置自定义header参数
        headers.forEach(conn::setRequestProperty);
    }

    private static String setParams(String url, Map<String, String> params) {
        if (params == null || params.size() <= 0) {
            return url;
        }
        StringBuilder sb = new StringBuilder(url);
        sb.append("?");
        params.forEach((k, v) -> sb.append(k).append("=").append(v).append("&"));
        return sb.substring(0, sb.length() - 1);
    }

    /**
     * 创建ssl连接(此版本跳过证书较验)
     * SSL协议位于TCP/IP协议与各种应用层协议之间，为数据通讯提供安全支持，提供如下支持：
     * 1）认证用户和服务器，确保数据发送到正确的客户机和服务器；
     * 2）加密数据以防止数据中途被窃取；
     * 3）维护数据的完整性，确保数据在传输过程中不被改变。
     *
     * @throws Exception
     */
    private static void httpssl(HttpURLConnection conn) throws Exception {
        TrustManager[] trustAllCerts = new TrustManager[1];
        TrustManager tm = new SslManager();
        trustAllCerts[0] = tm;
        SSLContext sc = SSLContext.getInstance("SSL");
//        javax.net.ssl.SSLContext sc = javax.net.ssl.SSLContext.getInstance("TLS");
        sc.init(null, trustAllCerts, new SecureRandom());
        ((HttpsURLConnection) conn).setSSLSocketFactory(sc.getSocketFactory());
        ((HttpsURLConnection) conn).setHostnameVerifier(new HostnameVerifier() {
            @Override
            public boolean verify(String str, SSLSession session) {
                return true;
            }
        });
    }

    /**
     * SSL双向认证，需要服务端和客户端均加载ca证书和客户端证书，并且支持私钥加密解密（双向解析签名）
     *
     * @param caAlias  服务端证书别名
     * @param caPath   服务端证书绝对路径
     * @param crtAlias 客户端证书别名
     * @param crtPath  客户端证书绝对路径
     * @param keyPath  密钥证书绝对路径
     * @param password 本地证书信任库密码，可以为空
     * @return
     * @throws Exception
     */
    private static SSLSocketFactory getSSLSocketFactory(String caAlias, String caPath, String crtAlias, String crtPath, String keyPath, String password) throws Exception {
        //CA证书是用来认证服务端的，CA就是一个公认的认证证书
        CertificateFactory cacf = CertificateFactory.getInstance("X.509");
        FileInputStream caInputStream = null;
        try {
            caInputStream = new FileInputStream(caPath);
        } catch (FileNotFoundException e) {
            log.error("https工具类中加载CA证书失败");
        }
        List<X509Certificate> caList = cacf.generateCertificates(caInputStream).stream().map(v ->
                (X509Certificate) v).collect(Collectors.toList());
        KeyStore keystore = KeyStore.getInstance("JKS");
        keystore.load(null, password.toCharArray());
        for (X509Certificate ca : caList) {
            keystore.setCertificateEntry(ca.getSubjectDN().getName(), ca);
        }
        TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
        tmf.init(keystore);
        //关闭文件流
        caInputStream.close();

        //crt客户端证书，发送给服务端做双向验证
        CertificateFactory crtcf = CertificateFactory.getInstance("X.509");
        InputStream crtStream = null;
        try {
            crtStream = new FileInputStream(new File(crtPath));
        } catch (FileNotFoundException e) {
            log.error("https工具类中加载客户端证书失败");
        }
        Certificate crt = crtcf.generateCertificate(crtStream);
        KeyStore crtks = KeyStore.getInstance(KeyStore.getDefaultType());
        crtks.load(null, password.toCharArray());
        crtks.setCertificateEntry(crtAlias, crt);
        //客户端私钥，处理双向SSL验证中服务端用客户端证书加密的数据的解密（解析签名）工具
        //加载openssl私钥文件并返回解析对象
        PrivateKey privateKey = null;
        try {
            privateKey = getPrivateKey(keyPath);
        } catch (Exception e) {
            log.error("https工具类中加载私钥失败");
        }
        crtks.setKeyEntry(crtAlias + ".private.key", privateKey, password.toCharArray(), new Certificate[]{crt});
        //初始化秘钥管理器
        KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
        kmf.init(crtks, password.toCharArray());
        //关闭文件流0
        crtStream.close();

        //注意，此处用TLSv1.2，需要服务端与客户端采用相同协议
        SSLContext sslContext = SSLContext.getInstance("TLSv1.2");
        // 第一个参数是授权的密钥管理器，用来授权验证。TrustManager[]第二个是被授权的证书管理器，用来验证服务器端的证书。第三个参数是一个随机数值，可以填写null
        sslContext.init(kmf.getKeyManagers(), tmf.getTrustManagers(), new SecureRandom());
        return sslContext.getSocketFactory();
    }

    /**
     * 解析openssl私钥文件
     *
     * @param keyPath
     * @return
     * @throws Exception
     */
    private static PrivateKey getPrivateKey(String keyPath) throws Exception {
        PrivateKey privKey = null;
        PemReader pemReader = null;
        File file = new File(keyPath);
        try {
            if (!file.exists()) {
                throw new FileNotFoundException("未找到私钥文件：" + keyPath);
            }
            pemReader = new PemReader(new FileReader(file));
            PemObject pemObject = pemReader.readPemObject();
            byte[] pemContent = pemObject.getContent();
            //支持从PKCS#1或PKCS#8 格式的私钥文件中提取私钥
            if (pemObject.getType().endsWith("RSA PRIVATE KEY")) {
                //取得私钥  for PKCS#1 , openssl genrsa 默认生成的私钥就是PKCS1的编码
                RSAPrivateKey asn1PrivKey = RSAPrivateKey.getInstance(pemContent);
                RSAPrivateKeySpec rsaPrivKeySpec = new RSAPrivateKeySpec(asn1PrivKey.getModulus(), asn1PrivKey.getPrivateExponent());
                KeyFactory keyFactory = KeyFactory.getInstance("rsa");
                privKey = keyFactory.generatePrivate(rsaPrivKeySpec);
            } else if (pemObject.getType().endsWith("PRIVATE KEY")) {
                //通过openssl pkcs8 -topk8转换为pkcs8，例如（-nocrypt不做额外加密操作）：
                //openssl pkcs8 -topk8 -in pri.key -out pri8.key -nocrypt
                //取得私钥 for PKCS#8
                PKCS8EncodedKeySpec privKeySpec = new PKCS8EncodedKeySpec(pemContent);
                KeyFactory kf = KeyFactory.getInstance("rsa");
                privKey = kf.generatePrivate(privKeySpec);
            }
        } finally {
            try {
                if (pemReader != null) {
                    pemReader.close();
                }
            } catch (IOException e) {
                log.error("系统异常", e);
            }
        }
        return privKey;
    }

    //TrustManager是JSSE 信任管理器的基接口，管理和接受提供的证书,通过JSSE可以很容易地编程实现对HTTPS站点的访问
    //X509TrustManager此接口的实例管理使用哪一个 X509 证书来验证远端的安全套接字
    public static class SslManager implements TrustManager, X509TrustManager {
        @Override
        public void checkClientTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
        }

        @Override
        public void checkServerTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
        }

        @Override
        public X509Certificate[] getAcceptedIssuers() {
            return new X509Certificate[0];
        }
    }

    /**
     * 此实体用于封装ssl请求，证书验证相关的keystroe信息
     */
    public static class SSLKeyStore {
        //ca证书别名
        private String caAlias;
        //ca存放绝对路径
        private String caPath;
        //客户端证书别名
        private String crtAlias;
        //客户端证书存放绝对路径
        private String crtPath;
        //客户端密钥存放绝对路径
        private String keyPath;
        //keystroey证书信任库访问密码，可以默认为null
        private String password;

        public String getCaAlias() {
            return caAlias;
        }

        public void setCaAlias(String caAlias) {
            this.caAlias = caAlias;
        }

        public String getCaPath() {
            return caPath;
        }

        public void setCaPath(String caPath) {
            this.caPath = caPath;
        }

        public String getCrtAlias() {
            return crtAlias;
        }

        public void setCrtAlias(String crtAlias) {
            this.crtAlias = crtAlias;
        }

        public String getCrtPath() {
            return crtPath;
        }

        public void setCrtPath(String crtPath) {
            this.crtPath = crtPath;
        }

        public String getKeyPath() {
            return keyPath;
        }

        public void setKeyPath(String keyPath) {
            this.keyPath = keyPath;
        }

        public String getPassword() {
            return password;
        }

        public void setPassword(String password) {
            this.password = password;
        }
    }


    public static SSLKeyStore getSSLKeyStore() {
        SSLKeyStore ssl = new SSLKeyStore();
        //ca 证书
        ssl.setCaAlias("ca");
        ssl.setCaPath(FilePathConfig.getInstance().getNormal() + "root.ca.pem");
        //公钥证书
        ssl.setCrtAlias("client");
        ssl.setCrtPath(FilePathConfig.getInstance().getNormal() + "ts.device.pem");
        //私钥
        ssl.setKeyPath(FilePathConfig.getInstance().getNormal() + "ts.device-prikey.pem");
        ssl.setPassword("changeit");
        return ssl;
    }

    public static void main(String[] args) throws Exception {
        //https 测试
        String httpsUrl = "https://cfbp.cf-noc.com/hello/postHello";
        String content = "{\"user_id\":\"1\"}";
        SSLKeyStore ssl = new SSLKeyStore();
        ssl.setCaAlias("ca");
        ssl.setCaPath("E:\\cert\\allca.crt");
        ssl.setCrtAlias("client");
        ssl.setCrtPath("E:\\cert\\ts.device.pem");
        ssl.setKeyPath("E:\\cert\\ts.device-prikey.pem");
        ssl.setPassword("changeit");
        String html = doSslPost(httpsUrl, null, null, content, ssl);
        System.out.println(html);
    }
}
那个女孩L
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
sslcontext-kickstart：:locked_with_key:一个轻量级的高级库，用于基于SSLContext或其他属性（例如TrustManager，KeyManager或Trusted Certificates）配置http客户端，以通过SSL TLS进行通信，以进行SSLFactory提供的单向身份验证或双向身份验证。 通过示例支持基于Java，Scala和Kotlin的客户端。 可用的客户端示例包括：Apache HttpClient，OkHttp，Spring RestTempla
02-05
SSLContext Kickstart :locked_with_key: 使用以下方法安装库： 用安装 < dependency> < groupId>io.github.hakky54</ groupId> < artifactId>sslcontext-kickstart</ artifactId> < version>6.2.0</ version> </ dependency> 使用Gradle安装 implementation ' io.github.hakky54:sslcontext-kickstart:6.2.0 ' 使用Scala SBT安装 libraryDe
Springboot项目配置Elasticsearch，设置账号密码后报javax.net.ssl.SSLHandshakeException: General SSLEngine problem
htx845928748的博客
07-28 6519
ES 报错：javax.net.ssl.SSLHandshakeException: General SSLEngine problem
mqtt java ssl_MQTT研究之EMQ：【SSL证书链验证】
weixin_33499715的博客
02-17 814
package com.taikang.iot.re.security;import org.apache.log4j.Logger;import org.bouncycastle.asn1.pkcs.RSAPrivateKey;import org.bouncycastle.util.io.pem.PemObject;import org.bouncycastle.util.io.pem.Pem...
SSLContext-Kickstart：让HTTPS安全配置变得轻松
最新发布
gitblog_00059的博客
04-26 322
SSLContext-Kickstart：让HTTPS安全配置变得轻松 项目地址:https://gitcode.com/Hakky54/sslcontext-kickstart SSLContext-Kickstart 是一个Python库，旨在简化和自动化创建SSL/TLS上下文的过程，这对于任何需要处理HTTPS连接或需要自定义SSL设置的应用来说都非常有用。该项目由Hakky54开发，它的...
ElasticSearch Client体验
qinghuazs的博客
09-17 1213
ElasticSearchClient体验
iis证书双向认证配置文档.doc
07-20
该配置主要包括五个关键步骤：服务器证书请求文件CSR的生成，证书的安装，SSL安全配置，证书的导出与导入，以及SSL双向认证的配置。 1. **服务器证书请求文件CSR的产生**： 在开始菜单中找到“程序”>“管理工具”...
Java如何跳过https的ssl证书验证详解
08-25
在针对http进行升级时，在HTTPS的证书未经权威机构认证的情况下，访问HTTPS站点的两种方法：一种方法是把该证书导入到Java的TrustStore文件中，另一种是自己实现并覆盖JSSE缺省的证书信任管理器类。 五、Java获取...
通讯加密证书 TLS详解.pdf
11-14
5. **CertificateRequest**：如果需要双向认证，则服务器会请求客户端证书。 6. **ServerHelloDone**：服务器完成握手阶段的消息发送。 7. **Certificate**（双向认证）：客户端发送自己的证书。 8. **...
使用OpenSSL来制作证书，在IIS中配置HTTPS（SSL）笔记.pdf
12-16
本文档详细介绍了如何使用OpenSSL为基于IIS的站点创建服务器端证书及客户端证书的方法，以及实现双向认证的步骤。通过这些步骤，不仅可以提高Web服务的安全性，还能增强用户数据的保护。在实际操作过程中，需要注意...
kickstart:kickstart是利用稳固性开发的区块链智能合约众筹Web应用程序
04-04
启动 kickstart是利用稳固性开发的区块链智能合约众筹网络应用程序。 技术领域 -以太坊是一个具有智能合约功能的去中心化开源区块链。 -Mocha是用于Node.js程序JavaScript测试框架，具有浏览器支持，异步测试，测试覆盖率报告以及任何断言库的使用。 -Node.js是一个开放源代码，跨平台JavaScript运行时环境，可在浏览器外部执行JavaScript代码。 -React是一个开放源代码的前端JavaScript库，用于构建用户界面或UI组件。 -实体是一种用于编写智能合约的面向对象的编程语言。 它用于在各种区块链平台上实施智能合约，最著名的是以太坊。 作者 詹姆斯·梁-初期作品
【最新版】KeyManager-3.13.0.dmg【亲测可用】最好的SSL证书申请和管理
05-14
提供安全便捷的SSL证书申请和管理 AES256位私钥加密存储，守护您的资产和品牌声誉。 全新UI，支持梦幻蓝/暗黑模式； 重新设计功能菜单，操作更友好； 支持恢复密钥，解决密码忘记问题； 如果恢复密钥也丢失，还支持重置密钥库； 修复一些bug, 提高稳定性，欢迎大家反馈问题，我们会及时修复； 高效的证书申请：自动的生成私钥和CSR并提交订单，待用户完成验证后自动存储证书合并私钥 便捷的证书管理：支持多种证书格式导入、导出功能，查看完整的证书信息。 安全的私钥存储： 使用AES256高强度算法加密存储。 证书服务商集成：可自由获得TrustAsia、Let’s Encrypt颁发的 免费证书。 支持自动化注册和安装 扩展能力。 证书发现：扫描网站并管理所有发现的证书。
当Jsoup遇到SSL加密站点
phone13144830339的博客
05-16 4275
import java.io.IOException; import java.security.SecureRandom; import java.security.cert.CertificateException; import java.security.cert.X509Certificate; import java.util.ArrayList; import java.util.L...
java 爬取ssl加密页面_一个爬取https和http通用的工具类(JDK自带的URL的用法)
weixin_29794879的博客
02-16 172
packagecn.qlq.craw.Jsoup;importjava.io.File;importjava.io.FileWriter;importjava.io.Writer;importjava.net.MalformedURLException;importjava.net.URL;importjava.security.SecureRandom;importjava.security.c...
解决jsoup抓取https问题
鱿鱼的博客
06-30 8654
在执行抓取之前让我们的站点信任所有站点，不需要引包，系统自带ssl证书校验 import javax.net.ssl.*; import java.security.SecureRandom; import java.security.cert.CertificateException; import java.security.cert.X509Certificate; public clas...
站点使用ssl加密方法
weixin_30707875的博客
06-25 192
1、先到域名管理申请SSL证书，然后下载IIS版本 2、将证书导入到windows，输入密码，选择自动选择存储区域 3、在IIS的服务器证书中导入刚刚下载的证书 4、在站点里面绑定选择https，端口443，SSL证书选择刚刚导入的名称。 转载于:https://www.cnblogs.com/liaoyi/p/11081759.html...
SecureCRT的Session编码全局设置
yuke的专栏
10-10 4865
在用SecureCRT连接Linux服务器时候，对于每一次的连接，Session的Character encoding都是Default，导致每次连接都得去修改为UTF-8，如下图： 因此需要修改他创建连接的参数默认值，我去查找了SecureCRT的安装目录，发现在“\config data\Sessions”目录下有“Default.ini“文件，其中有关编码的配置如下所示：
配置ssl证书
Daivon_Up的博客
07-28 922
配置ssl证书 将从腾讯云上下载的压缩包解压，里面包含 Apache， IIS, Nginx, Tomcat 文件夹，分别对应不同的部署方式。我们这里选择 Nginx 的部署方式 将 Nginx 文件夹下的两个文件直接拖动到此编辑器左侧的文件浏览器的 /etc/nginx 目录下，浏览器会自动将这两个文件上传到此服务器 编辑nginx配置文件 编辑 /etc/nginx/con...
SSL双向认证加密技术图解
HD243608836的博客
03-04 2387
前言 无论是单、双向加密的方式，对文件的加密最根源都是用的“对称密钥”加密（即一个“密码”） 因为"对称密钥"加密解密的速度、性能、资源损耗都是优于“非对称加密”的。而“非对称密钥”主要是用于验证身份。 一、单向加密 流程说明： A： 先使用“对称密钥”加密“原文”（得到“密文”）， 然后使用“公钥”加密“对称密钥”（得到“数字信封”） 传输 B： 先使用“私钥”解密“数字信封”（得到“对称密钥”）， 然后使用“对称密钥”解密“密文”（得到“原文”） 缺点： “B公钥”（B提
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值