解决JDK1.7,1.6不支持TLS1.2的问题

最新推荐文章于 2025-03-12 02:52:08 发布
最新推荐文章于 2025-03-12 02:52:08 发布
阅读量1.3w 收藏 9
点赞数 2
本文介绍了解决在使用JDK1.8开发过程中遇到的“ssl peer shut down incorrectly”错误的方法。通过创建自定义的TLSSocketConnectionFactory类，可以有效处理TLS1.2相关的问题，并提供了实现POST和GET请求的具体代码。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

开发过程中用JDK遇到ssl peer shut down incorrectly这个错误，是因为JDK1.8默认是TLS1.2

解决办法:

建立一个TLSSocketConnectionFactory，利用这个工具类，再写相关POST，GET方法就OK了

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;

/**
 * Created by hzlizhou on 2016/9/9.
 */
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
        };
    }
}
import javax.net.ssl.HttpsURLConnection;

import com.alibaba.fastjson.JSON;


import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.HttpURLConnection;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.net.URLConnection;


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) {
    	HttpsUrlConnectionForTLS httpsUrlConnectionMessageSender = new HttpsUrlConnectionForTLS();
    	String loginUrl = "https://192.168.186.73/session";
		String data = "username=xiaomi&password=Ultrasafe_123";
    	HttpURLConnection connection;
		try {
			connection = httpsUrlConnectionMessageSender.createConnection(new URI(loginUrl ));
			connection.setDoOutput(true);
	    	connection.setDoInput(true);
	    	connection.setRequestMethod("POST");
	    	connection.setUseCaches(false);
	    	connection.setInstanceFollowRedirects(true);
	    	connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");

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

 
			 if (connection != null) {
	    	        connection.disconnect();
	    	    }
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (URISyntaxException e) {
			// TODO Auto-generated catch block
			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();

        System.out.println(response);
        return response;
    }
}


解决jdk1.7 不支持TLS1.2的问题
02-09 6579
场景   java程序使用https方式调用nessus接口时，使用jdk1.7返回如下内容： javax.net.ssl.SSLException: Unrecognized SSL message, plaintext connection?  使用jdk1.8返回正常 {"token":"f360654233f65d964ed220914ec10916fe206a3d1b1c1b...
解决jdk1.6不支持TLS1.2协议的问题（javax.net.ssl.SSLHandshakeException: Received fatal alert: handshake_failure）
weixin_44450111的博客
12-06 5207
解决jdk1.6不支持TLS1.2协议的问题 项目场景： 两个系统对接，A方项目基于jdk1.6，B方项目基于jdk1.8,场景中A项目需要调用B项目的远程接口（https） 问题描述： 发现调用失败（javax.net.ssl.SSLHandshakeException: Received fatal alert: handshake_failure） 原因分析： B项目使用JDK1.8，https协议支持TLS1.2，而B项目是JDK1.6默认不支持TLS1.2 ，所以导致捂手失败# 学习目标：
请求https接口时的：SSLHandshakeException: Received fatal alert: handshake_failure
weixin_39075154的博客
08-09 807
调用3方接口一直异常，报错显示是SSL证书的问题。
对接服务升级后仅支持tls1.2，jdk1.7默认使用tls1.0，导致调用失败
weixin_32375369的博客
03-12 144
背景# 如标题所说，我手里维护了一个重要的老项目，使用jdk1.7，里面对接了很多个第三方服务，协议多种多样，其中涉及http/https的，调用方式也是五花八门，比如：commons-httpclient、apache httpclient、原生的url.openConnection()等。 Copy <dependency> <groupId>c...
javax.net.ssl.SSLHandshakeException: Received fatal alert: handshake_failure
H785503444的博客
04-03 4360
2、后来继续查询，从java8 Update31开始，由于SSL协议中的安全漏洞，默认情况下禁用SSL v3协议，需要找到jvm下的java.security文件，路径示例：jdk/Contents/Home/jre/lib/security，当然这种方法不建议使用，不安全，如有更好的方法，可以下面评论，共同学习共同进步。1、开始以为双方的协议不一致，修改了协议范围后，仍然不行。以上方法使用后问题依旧存在，于是就想着跳过这个协议验证。3、于是开启了第三种方法，来个釜底抽薪，
JDK1.6支持Tls1.2协议方法
qq_34097758的博客
05-11 1893
JDK1.6默认支持 TLS 1.0, SSLv3直到JDK1.6_121以上才支持TLSv1.2协议(收费)JDK1.7及以上默认支持TLSv1.1 TLSv1.2最近的工作需要在原有系统中集成访问另一个系统,在请求时https域名时涉及到一些安全性的问题,涉及到了TLS1.2。
jdk1.7个1.6的区别
05-24
3.安全性方面的改进：JDK 1.7中提供了更强的安全性保护，比如支持TLS1.2协议和RFC 5746，以及增强的XML安全性。 4.工具方面的改进：JDK 1.7中的工具有所改进，比如JConsole可以监控本地和远程进程，VisualVM可以...
javax.net.ssl.SSLHandshakeException: Received fatal alert: handshake_failure的一个解决方案-附件资源
03-05
javax.net.ssl.SSLHandshakeException: Received fatal alert: handshake_failure的一个解决方案-附件资源
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
weixin_44102162的博客
10-24 2854
这个错误信息表明在 SSL/TLS 握手过程中出现了问题，导致握手失败。通过以上具体做法，你可以更有效地排查并解决 SSL/TLS 握手失败的问题。表示在尝试建立安全连接时，服务器或客户端拒绝了握手。通过上述步骤，你可以逐步诊断并解决这个握手失败的问题。
搞定 javax.net.ssl.SSLHandshakeException: Received fatal alert: handshake_failure 问题！
dingyufei的博客
06-09 6392
开始碰到这个问题找遍了各种方法，其实还是需要耐心的先搞清楚原因再想方法靠谱，这里也总结下这个异常的多种解决方案， 首先先理解下为什么出现handshake？字面理解是客户端与服务端握手失败，能导致握手失败的原因是什么？ 一.协议版本不同 首先是两边版本协议不一致，例如客户端可能是jdk7 /jdk8 它们支持的协议参考这里https://emacsist.github.io/2017/03/02/https.protocols%E5%9C%A8java%E4%B8%AD%E7%9A%84%E4%BD%
eclipse javax.net.ssl.SSLHandshakeException: Received fatal alert: handshake_failure
----------------
02-16 3529
当eclipse下载插件时有这样的提示时需要去 oracle官网下载两个 jar包 JDK8 http://www.oracle.com/technetwork/java/javase/downloads/jce8-download-2133166.htmlJAVA_HOME/jre/lib/security 目录下 US_export_policy.jar 与 local_policy.
【笔记】记一次HTTPS请求SSLHandshakeException: Received fatal alert: handshake_failure异常问题
欢迎光临
04-14 3544
最近在项目中使用Hutools 请求HTTPS接口出现SSLHandshakeException: Received fatal alert: handshake_failure异常，经过排查属于JDK版本中安全机制导致，不同https安全协议不一致，可能是TLSv1.2,TLSv1.1,TLSv1.3等，TLS协议版本越高，HTTPS通信的安全性越高，但是相较于低版本TLS协议，高版本TLS协议对浏览器的兼容性较差。
jdk1.6 不支持ECDH
最新发布
03-28
<think>好的，我需要回答用户关于JDK 1.6不支持ECDH的问题，以及替代方案或升级建议。首先，我得确认JDK 1.6确实不支持ECDH。根据用户提供的引用[1]，JDK 1.6支持的SSL协议版本包括SSLv2Hello、SSLv3、TLSv1。但ECDH属于密钥交换算法，可能不在其中。 接下来，我需要解释为什么JDK 1.6不支持ECDH。可能的原因包括JDK版本较老，当时椭圆曲线加密（ECC）还未普及，或者Sun/Oracle在后续版本才加入对ECDH的支持。需要查证JDK版本更新历史，确认ECDH的支持情况。例如，JDK 1.7可能开始支持更强的算法。 然后，替代方案方面，用户可能无法立即升级JDK，所以需要其他方法。可能的方案包括使用第三方库如Bouncy Castle来提供ECDH支持，或者调整SSL/TLS配置，使用JDK 1.6支持的密钥交换算法，比如RSA或DHE。不过需要注意这些算法的安全性可能较弱，可能存在风险。 升级建议部分，应推荐升级到更高版本的JDK，如1.7或1.8，因为这些版本支持更多的协议和算法，包括ECDH和更安全的TLS版本。同时，引用[1]提到JDK 1.7和1.8支持TLSv1.1和TLSv1.2，这增强了安全性。 另外，用户的问题中提到SSL协议版本，但ECDH属于密钥交换机制，可能属于 cipher suite 的一部分。需要明确区分协议版本和加密套件。例如，即使使用TLSv1，如果JDK 1.6的默认加密套件不包含ECDH相关的，那么也无法使用。因此，可能需要手动配置加密套件，但不确定是否可行。 还需考虑实际应用场景，比如服务器配置是否需要ECDH。如果必须使用ECDH，那么升级JDK可能是唯一选择。若不能升级，可能需要替换加密算法，但这可能影响兼容性和安全性。 最后，确保回答结构清晰，分点说明原因、替代方案和升级建议，并引用提供的资料。例如，引用[1]说明JDK版本支持的协议，引用[2]关于修改配置的方法可能不适用，但引用[3]提到代码分析工具可能帮助检测相关问题。</think>### JDK 1.6不支持ECDH的原因及解决方案 #### 1. **JDK 1.6不支持ECDH的原因** - **算法支持限制**：JDK 1.6发布于2006年，当时椭圆曲线密码学（ECC）尚未被广泛采用，因此未原生支持基于椭圆曲线的密钥交换算法（如ECDH）[^1]。 - **协议版本限制**：JDK 1.6默认支持的SSL/TLS协议版本为TLSv1，而ECDH通常在更高版本的协议（如TLSv1.2）中结合现代加密套件使用[^1]。 --- #### 2. **替代方案** - **使用第三方加密库** 引入如**Bouncy Castle**等库，通过扩展JDK的加密能力实现ECDH支持。例如： ```java Security.addProvider(new BouncyCastleProvider()); ``` 需在代码中显式指定加密套件（如`TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA`）。 - **降级使用传统算法** 若无法集成第三方库，可改用JDK 1.6支持的密钥交换算法（如RSA或DHE），但需注意**安全性风险**（例如DHE可能存在性能问题，RSA缺乏前向保密性）。 --- #### 3. **升级建议** - **升级至JDK 1.7或更高版本** JDK 1.7及以上版本原生支持ECDH和TLSv1.2，例如： ```java // JDK 1.7+支持的加密套件示例 SSLParameters params = sslEngine.getSSLParameters(); params.setProtocols(new String[]{"TLSv1.2"}); ``` 同时兼容现代安全标准（如SNI、ALPN）。 - **服务器端兼容性配置** 若服务端需支持JDK 1.6客户端，可配置双协议栈（如同时启用TLSv1和TLSv1.2），但需权衡安全性。 --- #### 4. **风险与验证** - **安全性风险**：传统算法（如SSLv3、RSA）易受POODLE、BEAST等攻击，建议通过工具（如**SonarQube**[^3]）扫描代码中的弱加密配置。 - **功能验证**：使用`jdk.tls.disabledAlgorithms`参数测试兼容性，例如： ``` java -Djava.security.properties=disabled_algorithms.config ``` ---
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值