HTTPS请求握手失败javax.net.ssl.SSLHandshakeException: Received fatal alert: handshake_failu

最新推荐文章于 2024-05-22 12:31:19 发布
最新推荐文章于 2024-05-22 12:31:19 发布
阅读量8.3k 收藏 9
点赞数 6
分类专栏： 杂货店 文章标签： HTTPS失败 SSLException protocol_vers handshake
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Kevin_King1992/article/details/108416934
版权

报错信息：
main, handling exception: javax.net.ssl.SSLHandshakeException: Received fatal alert: handshake_failure

错误解析：https请求时三次握手失败
在这里插入图片描述
分析原因：因为我司使用jdk1.8，而对方对接公司使用jdk7
什么操作都不做的情况下报错如下图：

main, handling exception: javax.net.ssl.SSLException: Received fatal alert: protocol_version

在这里插入图片描述
明显是客户端与服务端TLS版本不一致导致的，1.8默认是TLSv1.2,1.7默认支持是TLSv1；

解决的办法很多：
1.启动jvm加参数：-Dhttps.protocols=TLSv1.2,TLSv1.1
2.http发送的时候，设置，如：

SSLContext sslContext = SSLContexts.createDefault();

SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslContext,
        new String[]{"TLSv1.2","TLSv1.1","TLSv1","SSLv3"},
        null,
        new NoopHostnameVerifier());

CloseableHttpClient httpClient = HttpClients.custom()
        .setSSLSocketFactory(sslsf)
        .build();

System.setProperty("https.protocols", "TLSv1.2,TLSv1.1,TLSv1,SSLv3");

以上三种方法都可以解决TLSv1.2 报错protocol_version的问题;

解决完上面的protocol_version之后，会继续报文章开头握手的错误，解决方法如下：

解决方案第三方框架：Bouncy Castle

<dependency>
    <groupId>org.bouncycastle</groupId>
    <artifactId>bcprov-ext-jdk15on</artifactId>
    <version>1.58</version>
</dependency>

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.security.KeyStore;
import java.security.Principal;
import java.security.SecureRandom;
import java.security.Security;
import java.security.cert.CertificateExpiredException;
import java.security.cert.CertificateFactory;
import java.util.Hashtable;
import java.util.LinkedList;
import java.util.List;

import javax.net.ssl.HandshakeCompletedListener;
import javax.net.ssl.SSLPeerUnverifiedException;
import javax.net.ssl.SSLSession;
import javax.net.ssl.SSLSessionContext;
import javax.net.ssl.SSLSocket;
import javax.net.ssl.SSLSocketFactory;
import javax.security.cert.X509Certificate;

import org.bouncycastle.crypto.tls.*;
import org.bouncycastle.crypto.tls.Certificate;
import org.bouncycastle.jce.provider.BouncyCastleProvider;

public class TLSSocketConnectionFactory extends SSLSocketFactory {

    static {
        if (Security.getProvider(BouncyCastleProvider.PROVIDER_NAME) == null) {
            Security.addProvider(new BouncyCastleProvider());
        }
    }

    @Override
    public Socket createSocket(Socket socket, final String host, int port,
                               boolean arg3) throws IOException {
        if (socket == null) {
            socket = new Socket();
        }
        if (!socket.isConnected()) {
            socket.connect(new InetSocketAddress(host, port));
        }

        final TlsClientProtocol tlsClientProtocol = new TlsClientProtocol(socket.getInputStream(), socket.getOutputStream(), new SecureRandom());

        return _createSSLSocket(host, tlsClientProtocol);
    }

    @Override
    public String[] getDefaultCipherSuites() {
        return null;
    }

    @Override
    public String[] getSupportedCipherSuites() {
        return null;
    }

    @Override
    public Socket createSocket(String host, int port) throws IOException, UnknownHostException {
        throw new UnsupportedOperationException();
    }

    @Override
    public Socket createSocket(InetAddress host, int port) throws IOException {
        throw new UnsupportedOperationException();
    }

    @Override
    public Socket createSocket(String host, int port, InetAddress localHost, int localPort) throws IOException, UnknownHostException {
        return null;
    }

    @Override
    public Socket createSocket(InetAddress address, int port, InetAddress localAddress, int localPort) throws IOException {
        throw new UnsupportedOperationException();
    }

    private SSLSocket _createSSLSocket(final String host, final TlsClientProtocol tlsClientProtocol) {
        return new SSLSocket() {
            private java.security.cert.Certificate[] peertCerts;

            @Override
            public InputStream getInputStream() throws IOException {
                return tlsClientProtocol.getInputStream();
            }

            @Override
            public OutputStream getOutputStream() throws IOException {
                return tlsClientProtocol.getOutputStream();
            }

            @Override
            public synchronized void close() throws IOException {
                tlsClientProtocol.close();
            }

            @Override
            public void addHandshakeCompletedListener(HandshakeCompletedListener arg0) {
            }

            @Override
            public boolean getEnableSessionCreation() {
                return false;
            }

            @Override
            public String[] getEnabledCipherSuites() {
                return null;
            }

            @Override
            public String[] getEnabledProtocols() {
                return null;
            }

            @Override
            public boolean getNeedClientAuth() {
                return false;
            }

            @Override
            public SSLSession getSession() {
                return new SSLSession() {

                    @Override
                    public int getApplicationBufferSize() {
                        return 0;
                    }

                    @Override
                    public String getCipherSuite() {
                        throw new UnsupportedOperationException();
                    }

                    @Override
                    public long getCreationTime() {
                        throw new UnsupportedOperationException();
                    }

                    @Override
                    public byte[] getId() {
                        throw new UnsupportedOperationException();
                    }

                    @Override
                    public long getLastAccessedTime() {
                        throw new UnsupportedOperationException();
                    }

                    @Override
                    public java.security.cert.Certificate[] getLocalCertificates() {
                        throw new UnsupportedOperationException();
                    }

                    @Override
                    public Principal getLocalPrincipal() {
                        throw new UnsupportedOperationException();
                    }

                    @Override
                    public int getPacketBufferSize() {
                        throw new UnsupportedOperationException();
                    }

                    @Override
                    public X509Certificate[] getPeerCertificateChain() throws SSLPeerUnverifiedException {
                        return null;
                    }

                    @Override
                    public java.security.cert.Certificate[] getPeerCertificates() throws SSLPeerUnverifiedException {
                        return peertCerts;
                    }

                    @Override
                    public String getPeerHost() {
                        throw new UnsupportedOperationException();
                    }

                    @Override
                    public int getPeerPort() {
                        return 0;
                    }

                    @Override
                    public Principal getPeerPrincipal() throws SSLPeerUnverifiedException {
                        return null;
                    }

                    @Override
                    public String getProtocol() {
                        throw new UnsupportedOperationException();
                    }

                    @Override
                    public SSLSessionContext getSessionContext() {
                        throw new UnsupportedOperationException();
                    }

                    @Override
                    public Object getValue(String arg0) {
                        throw new UnsupportedOperationException();
                    }

                    @Override
                    public String[] getValueNames() {
                        throw new UnsupportedOperationException();
                    }

                    @Override
                    public void invalidate() {
                        throw new UnsupportedOperationException();
                    }

                    @Override
                    public boolean isValid() {
                        throw new UnsupportedOperationException();
                    }

                    @Override
                    public void putValue(String arg0, Object arg1) {
                        throw new UnsupportedOperationException();
                    }

                    @Override
                    public void removeValue(String arg0) {
                        throw new UnsupportedOperationException();
                    }
                };
            }

            @Override
            public String[] getSupportedProtocols() {
                return null;
            }

            @Override
            public boolean getUseClientMode() {
                return false;
            }

            @Override
            public boolean getWantClientAuth() {
                return false;
            }

            @Override
            public void removeHandshakeCompletedListener(HandshakeCompletedListener arg0) {
            }

            @Override
            public void setEnableSessionCreation(boolean arg0) {
            }

            @Override
            public void setEnabledCipherSuites(String[] arg0) {
            }

            @Override
            public void setEnabledProtocols(String[] arg0) {
            }

            @Override
            public void setNeedClientAuth(boolean arg0) {
            }

            @Override
            public void setUseClientMode(boolean arg0) {
            }

            @Override
            public void setWantClientAuth(boolean arg0) {
            }

            @Override
            public String[] getSupportedCipherSuites() {
                return null;
            }

            @Override
            public void startHandshake() throws IOException {
                tlsClientProtocol.connect(new DefaultTlsClient() {

                    @SuppressWarnings("unchecked")
                    @Override
                    public Hashtable<Integer, byte[]> getClientExtensions() throws IOException {
                        Hashtable<Integer, byte[]> clientExtensions = super.getClientExtensions();
                        if (clientExtensions == null) {
                            clientExtensions = new Hashtable<Integer, byte[]>();
                        }

                        //Add host_name
                        byte[] host_name = host.getBytes();

                        final ByteArrayOutputStream baos = new ByteArrayOutputStream();
                        final DataOutputStream dos = new DataOutputStream(baos);
                        dos.writeShort(host_name.length + 3);
                        dos.writeByte(0);
                        dos.writeShort(host_name.length);
                        dos.write(host_name);
                        dos.close();
                        clientExtensions.put(ExtensionType.server_name, baos.toByteArray());
                        return clientExtensions;
                    }

                    @Override
                    public TlsAuthentication getAuthentication() throws IOException {
                        return new TlsAuthentication() {
                            @Override
                            public void notifyServerCertificate(Certificate serverCertificate) throws IOException {
                                try {
                                    KeyStore ks = _loadKeyStore();

                                    CertificateFactory cf = CertificateFactory.getInstance("X.509");
                                    List<java.security.cert.Certificate> certs = new LinkedList<java.security.cert.Certificate>();
                                    boolean trustedCertificate = false;
                                    for (org.bouncycastle.asn1.x509.Certificate c : ((org.bouncycastle.crypto.tls.Certificate) serverCertificate).getCertificateList()) {
                                        java.security.cert.Certificate cert = cf.generateCertificate(new ByteArrayInputStream(c.getEncoded()));
                                        certs.add(cert);

                                        String alias = ks.getCertificateAlias(cert);
                                        if (alias != null) {
                                            if (cert instanceof java.security.cert.X509Certificate) {
                                                try {
                                                    ((java.security.cert.X509Certificate) cert).checkValidity();
                                                    trustedCertificate = true;
                                                } catch (CertificateExpiredException cee) {
                                                    // Accept all the certs!
                                                }
                                            }
                                        } else {
                                            // Accept all the certs!
                                        }

                                    }
                                    if (!trustedCertificate) {
                                        // Accept all the certs!
                                    }
                                    peertCerts = certs.toArray(new java.security.cert.Certificate[0]);
                                } catch (Exception ex) {
                                    ex.printStackTrace();
                                    throw new IOException(ex);
                                }
                            }

                            @Override
                            public TlsCredentials getClientCredentials(CertificateRequest certificateRequest) throws IOException {
                                return null;
                            }

                            private KeyStore _loadKeyStore() throws Exception {
                                FileInputStream trustStoreFis = null;
                                try {
                                    KeyStore localKeyStore = null;

                                    String trustStoreType = System.getProperty("javax.net.ssl.trustStoreType") != null ? System.getProperty("javax.net.ssl.trustStoreType") : KeyStore.getDefaultType();
                                    String trustStoreProvider = System.getProperty("javax.net.ssl.trustStoreProvider") != null ? System.getProperty("javax.net.ssl.trustStoreProvider") : "";

                                    if (trustStoreType.length() != 0) {
                                        if (trustStoreProvider.length() == 0) {
                                            localKeyStore = KeyStore.getInstance(trustStoreType);
                                        } else {
                                            localKeyStore = KeyStore.getInstance(trustStoreType, trustStoreProvider);
                                        }

                                        char[] keyStorePass = null;
                                        String str5 = System.getProperty("javax.net.ssl.trustStorePassword") != null ? System.getProperty("javax.net.ssl.trustStorePassword") : "";

                                        if (str5.length() != 0) {
                                            keyStorePass = str5.toCharArray();
                                        }

                                        localKeyStore.load(trustStoreFis, keyStorePass);

                                        if (keyStorePass != null) {
                                            for (int i = 0; i < keyStorePass.length; i++) {
                                                keyStorePass[i] = 0;
                                            }
                                        }
                                    }
                                    return localKeyStore;
                                } finally {
                                    if (trustStoreFis != null) {
                                        trustStoreFis.close();
                                    }
                                }
                            }

                        };
                    }

                });
            } // startHandshake
        };
    }
}


/**
 * @author Kevin
 */
public class HttpsUrlConnectionForTLS {

    public HttpURLConnection createConnection(URI uri) throws IOException {
        URL url = uri.toURL();
        URLConnection connection = url.openConnection();
        HttpsURLConnection httpsURLConnection = (HttpsURLConnection) connection;
        httpsURLConnection.setSSLSocketFactory(new TLSSocketConnectionFactory());
        return httpsURLConnection;
    }

    public static void main(String[] args) throws Exception {
        String apiUrl = BIGTREE_URL;
        /*接口参数包装*/
        String json = "{\"userName\":\"test\",\"userType\":\"02\"}";
        Map paramMap = JSONObject.parseObject(json, Map.class);

        String newparams = JSON.toJSONString(paramMap);
        System.out.println(apiUrl);

        /*每次接口调用生成随机加密字符串*/
        String x_bigtree_nonce = Utils.makeRandomStr(16);

        //AES加密(去掉空格和换行)
        String aesJsonStr = Utils.encrypt(newparams, ACCESS_KEY, x_bigtree_nonce).replaceAll(REPLACE_STR, "");
        //签名规则
        String signRule = ACCESS_KEY + aesJsonStr + X_BIGTREE_APPID + x_bigtree_nonce;
        //MD5签名(去掉空格和换行)
        String sign = Utils.md5(signRule.replaceAll(REPLACE_STR, ""));
        Map<String, String> param = new HashMap<String, String>();
        param.put("data", URLEncoder.encode(aesJsonStr, "UTF-8"));
        System.out.println("nonce:" + x_bigtree_nonce + ",sign:" + sign);
        System.out.println("sign:" + sign);
        System.out.println("data:" + param.get("data"));
        System.out.println("requestParam:" + JSON.toJSONString(param));


        // post请求是将参数放在请求体里面传过去的;这里将entity放入post请求体中
        Map<String, String> headers = new HashMap<String, String>();
        headers.put("Content-Type", "application/json;charset=utf8");
        headers.put("x-bigtree-appid", X_BIGTREE_APPID);
        headers.put("x-bigtree-nonce", x_bigtree_nonce);
        headers.put("x-bigtree-sign", sign);
        headers.put("Content-Type", "application/json;charset=utf-8");

        doPost(apiUrl, JSON.toJSONString(param), headers);
    }

    private static void doPost(String url, String body, Map<String, String> headers) {
        HttpsUrlConnectionForTLS httpsUrlConnectionMessageSender = new HttpsUrlConnectionForTLS();
        HttpURLConnection connection;
        try {
            connection = httpsUrlConnectionMessageSender.createConnection(new URI(url));
            connection.setDoOutput(true);
            connection.setDoInput(true);
            connection.setRequestMethod("POST");
            connection.setUseCaches(false);
            connection.setInstanceFollowRedirects(true);
            if (headers != null && headers.size() > 0) {
                for (String key : headers.keySet()) {
                    connection.setRequestProperty(key, headers.get(key));
                }
            }

            connection.connect();
            //POST请求
            OutputStreamWriter os = null;
            String json = "";
            os = new OutputStreamWriter(connection.getOutputStream());
            os.write(body);
            os.flush();
            json = getResponse(connection);
            System.out.println(json);

            if (connection != null) {
                connection.disconnect();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (URISyntaxException e) {
            e.printStackTrace();
        }
    }

    public static String getResponse(HttpURLConnection Conn) throws IOException {
        InputStream is;
        if (Conn.getResponseCode() >= 400) {
            is = Conn.getErrorStream();
        } else {
            is = Conn.getInputStream();
        }

        String response = "";
        byte buff[] = new byte[512];
        int b = 0;
        while ((b = is.read(buff, 0, buff.length)) != -1) {
            response += new String(buff, 0, b);

        }
        is.close();

        return response;
    }
}

参考：https://www.iteye.com/blog/ligaosong-2356346

吃饼青年
关注
  • 6
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
javax.net.ssl.SSLHandshakeException：收到致命警报：handshake_failure [重复]
Spark
01-03 1066
javax.net.ssl.SSLHandshakeException：收到致命警报：handshake_failure [重复] 问问题 问3年零6个月前 活跃2年零4个月前 观看了83k次 18岁 11 这个问题已经在这里有了答案： 收到致命警报：通过SSLHandshakeException的handshake_failur...
SSLHandshakeException:Received fatal alert:handshake_failure
FFFFFFFFFFFFFFish的博客
05-27 1911
handling exception: javax.net.ssl.SSLHandshakeException: Received fatal alert: handshake_failure Java发送请求握手失败问题解决方法1方法2方法3 方法1 在eclipse中的 Window - Preference - Tomcact/Resin - JDK - Optional Java VM arguments 中增加配置： Dhttps.protocols=TLSv1.3,TLSv1.2,TLSv1
javax.net.ssl.SSLHandshakeException: Received fatal alert: handshake_failure的一个解决方案-附件资源
03-05
javax.net.ssl.SSLHandshakeException: Received fatal alert: handshake_failure的一个解决方案-附件资源
SSL：javax.net.ssl.SSLException: Received fatal alert: protocol_version
最新发布
wimpykids的博客
05-22 1350
javax.net.ssl.SSLException: Received fatal alert: protocol_version
javax.net.ssl.SSLHandshakeException: Received fatal alert: handshake_failure
风语落尘
05-06 7606
1、找到jvm下的java.security文件，Mac电脑路径示例：/Library/Java/JavaVirtualMachines/jdk1.8.0_311.jdk/Contents/Home/jre/lib/security。2、编辑java.security文件，找到参数 jdk.tls.disabledAlgorithms 这一行，删除掉RC4 前面的几个值 即可。排查过程：可使用如下代码，打印http请求协议过程。修改后如下，重新请求地址，请求正常，问题解决。
Received fatal alert:handshake_failure 异常解决方法
weixin_40461030的博客
01-15 2万+
目录 1.背景 2. 报错信息 3.问题分析 4. 解决方法 1.背景 PCI认证，要求安全传输层协议由之前的TLS v1.0、TLS v1.1升级到TLS v1.2。 2. 报错信息 java.lang.Exception: 接口调用失败: at com.huateng.szairpay.common.utils.HTTPSInvoke.sendHttpsRequest...
javax.net.ssl.SSLException: Received fatal alert: protocol_version解决
热门推荐
心寒的博客
04-07 2万+
javax.net.ssl.SSLException解决方法
SSLHandshakeException: Received fatal alert: handshake_failure
jiangjun0130的博客
05-15 1万+
问题出现： jdk版本从7升级到8之后，出现ssl异常信息：具体错误信息如下：问题定位 关于ssl握手异常，网上有很多。大多数的解决方式都是修改protocols、cipherSuites、修改${JAVA_HOME}/lib/security的local_policy.jar、US_export_policy.jar或者修改jdk版本。 在尝试了所有的方法法之后，还是握手异常。最后在启动ja
Received fatal alert: handshake_failure
w_zhendefu的博客
01-14 2176
错误 错误描述：向第三方服务发送https请求的时候产生 Received fatal alert: handshake_failure 异常。 问题原因：使用的是jdk1.6。而请求需要的是TSLv1.2,jdk1.6默认的请求是TSLv1,故协议不正确，导致请求失败。 解决问题： 配置eclipse的调试日志。引入tsl请求的日志输出。 控制栏选择run -> run configur...
解决webMagic0.7.3 出现javax.net.ssl.SSLException: Received fatal alert: protocol_version的问题-附件资源
03-02
解决webMagic0.7.3 出现javax.net.ssl.SSLException: Received fatal alert: protocol_version的问题-附件资源
javax.net.ssl.SSLException: java.lang.RuntimeException: Could not generate DH keypair 解决方法总结
08-25
主要介绍了javax.net.ssl.SSLException: java.lang.RuntimeException: Could not generate DH keypair 解决方法，有需要的朋友们可以学习下。
javax.net.ssl.SSLHandshakeException: Handshake failed
maqiang88的专栏
11-07 1109
1、协议和算法如下时，客户端正常登录 sslProtocol = "TLS"    ciphers="TLS_RSA_WITH_AES_128_CBC_SHA256,  TLS_RSA_WITH_AES_128_CBC_SHA,  TLS_RSA_WITH_AES_256_CBC_SHA256,  TLS_RSA_WITH_AES_256_CBC_SHA,  SSL_RSA_WITH_
javax.net.ssl.SSLException: Received fatal alert: protocol_version问题解决
weixin_39755884的博客
01-26 1779
看中文名字是协议版本出了问题 其实就是TLS协议出现了问题 如果是支持TLSv1.2 用的TLSv1.1的话就会报这个错 先看看报错日志，里面有没有TLSv1.1出现如果有的话，那就是问题所在喽
Spring boot2.0 入门(十一)-RestTemplate使用https访问
u011311291的博客
03-24 1081
package com.zte.apt.ZXAPTDS_Agent.utils; import java.io.IOException; import java.net.HttpURLConnection; import java.net.InetAddress; import java.net.Socket; import java.security.cert.X509Certificate;...
解决javax.net.ssl.SSLHandshakeException: Received fatal alert: handshake_failure报错
Joker的博客
12-21 1463
背景 java版本1.8.0,今天尝试用Java去访问一个https接口，但抛出下面的异常： javax.net.ssl.SSLHandshakeException: Received fatal alert: handshake_failure 原因 从java8 Update31开始，由于SSL协议中的安全漏洞，默认情况下禁用SSL v3协议。 解决办法 找到jdk 1.8安装目录，例如我的java文件夹叫jdk1.8.0_301 找到该目录下的java.security..
解决Java调用Azure SDK证书错误javax.net.ssl.SSLHandshakeException
weixin_30460489的博客
12-05 1160
Azure作为微软的公有云平台，提供了非常丰富的SDK和API让开发人员可以非常方便的调用的各项服务，目前除了自家的.NET, Java, Python, nodeJS, Ruby，PHP等语言都提供支持，详细的文档说明请参考： https://azure.microsoft.com/en-us/documentation/ 然而在使用过程中，以Java语言为例，在初始调用Azure SDK...
Caused by: javax.net.ssl.SSLException: Received fatal alert: protocol_version
面朝大海，春暖花开
12-17 1332
Caused by: javax.net.ssl.SSLException: Received fatal alert: protocol_version
jdk1.7支持TLS设置及URLConnection的使用
04-02 2982
今天写图片下载功能代码，主要功能是将服务器上的图片下载保存，在访问服务器端时，由于是使用的HttpsConnection，结果在conn=url.openconnection()后，用conn.getInputStream()时，出现了异常 握手失败？一看应该是网络连接问题，上百度查了一下，发现资源还是很多的，主要原因，JDK1.7与JDK1.8的SSL协议兼容问题，我本机是1.7，服务器是...
javax.net.ssl.SSLException: Received fatal alert: handshake_failure
09-23
您遇到的这个错误 `javax.net.ssl.SSLException: Received fatal alert: handshake_failure` 是由于SSL握手失败引起的。SSL握手是在建立安全连接时进行的过程，它包括验证服务器的身份和协商加密算法等步骤。 这个错误可能有以下几种原因和解决方法： 1. 协议版本不匹配：可能是客户端和服务器之间的SSL/TLS协议版本不兼容。请尝试将Java运行环境配置为使用更高的协议版本。例如，您可以尝试使用`-Dhttps.protocols=TLSv1.2`参数来指定使用TLSv1.2协议。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值