发布于 由admin

JAVA 集成第三方 API 报 SSLHandshakeException？根证书更新解决流程

JAVA 集成第三方 API 报 SSLHandshakeException？根证书更新解决流程

大家好，今天我们来聊聊在 Java 集成第三方 API 时，遇到 SSLHandshakeException 的问题，以及如何通过更新根证书来解决。这是一个很常见的问题，特别是在对接一些使用了自签名证书或者过期证书的第三方 API 时。

1. 理解 SSL/TLS 握手流程和 SSLHandshakeException

在深入解决方案之前，我们需要先理解 SSL/TLS 握手流程，以及 SSLHandshakeException 产生的原因。

SSL/TLS (Secure Sockets Layer/Transport Layer Security) 是一种安全协议，用于在客户端和服务器之间建立加密连接。这个过程涉及到一系列的步骤，我们称之为握手：

  1. 客户端发起连接请求 (Client Hello): 客户端发送一个 "Client Hello" 消息给服务器，包含客户端支持的 TLS 版本、加密算法套件列表、以及一个随机数。
  2. 服务器响应 (Server Hello): 服务器收到 "Client Hello" 消息后，选择一个 TLS 版本和加密算法套件，并发送一个 "Server Hello" 消息给客户端，包含服务器选择的 TLS 版本、加密算法套件、服务器证书、以及一个随机数。
  3. 服务器证书验证: 客户端收到服务器的证书后，需要验证证书的有效性。这个验证过程包括：
    • 证书链验证: 客户端需要验证服务器证书是否由一个受信任的根证书颁发机构 (Root CA) 签名。如果服务器证书不是由直接信任的根证书签名，客户端会尝试查找中间证书，直到找到一个受信任的根证书。
    • 证书有效期验证: 客户端需要验证证书是否在有效期内。
    • 证书吊销列表 (CRL) 验证: 客户端可以验证证书是否被吊销。
    • 主机名验证: 客户端需要验证证书中的主机名是否与服务器的主机名匹配。
  4. 密钥交换: 客户端和服务器使用密钥交换算法来协商一个共享的秘密密钥。
  5. 加密通信: 客户端和服务器使用共享的秘密密钥来加密和解密后续的通信数据。

如果握手过程中的任何一个步骤失败，都可能导致 SSLHandshakeException。 常见的导致 SSLHandshakeException 的原因包括：

  • 服务器证书不受信任: 服务器使用的证书是由一个未知的或者不受信任的根证书颁发机构签名的。这通常发生在服务器使用了自签名证书或者私有 CA 颁发的证书时。
  • 服务器证书已过期: 服务器使用的证书已经过期。
  • 客户端不支持服务器使用的加密算法套件: 客户端不支持服务器选择的加密算法套件。
  • 客户端使用的 TLS 版本过低: 客户端使用的 TLS 版本低于服务器要求的最低 TLS 版本。
  • 主机名验证失败: 证书中的主机名与服务器的主机名不匹配。

2. 定位 SSLHandshakeException 的原因

当遇到 SSLHandshakeException 时，我们需要首先定位问题的根源。 通常，异常信息会提供一些线索。

javax.net.ssl.SSLHandshakeException: sun.security.validator.ValidatorException: PKIX path building failed: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target

这个异常信息表明，Java 无法找到一条有效的证书路径，从而无法验证服务器证书的有效性。 这通常意味着客户端缺少必要的根证书。

另一种可能的异常信息：

javax.net.ssl.SSLHandshakeException: Received fatal alert: certificate_expired

这个异常信息表明服务器的证书已过期。

3. 解决 SSLHandshakeException 的步骤

解决 SSLHandshakeException 的主要步骤如下：

  1. 获取服务器证书:

    • 可以使用浏览器访问服务器，然后导出服务器证书。 不同浏览器的导出方式略有不同，通常可以在浏览器地址栏的锁形图标中找到证书信息，然后导出证书。

    • 也可以使用 OpenSSL 命令来获取服务器证书：

      openssl s_client -showcerts -connect yourdomain.com:443

      这条命令会连接到 yourdomain.com 的 443 端口，并显示服务器证书链。将证书链中的服务器证书保存到文件中 (例如 server.crt)。 注意复制的时候要把 -----BEGIN CERTIFICATE----- 和 -----END CERTIFICATE----- 也复制上。

  2. 确定是否是根证书问题:

    • 使用 keytool 命令查看服务器证书的信息：

      keytool -printcert -file server.crt

      查看证书的颁发者 (Issuer) 信息。 如果颁发者是一个你未知的或者不受信任的根证书颁发机构，那么很可能就是根证书问题。

  3. 更新 Java 的信任证书库 (cacerts):

    • Java 的信任证书库 cacerts 位于 $JAVA_HOME/jre/lib/security/cacerts。 $JAVA_HOME 指的是你的 JDK 安装目录。

    • 备份 cacerts 文件: 在进行任何更改之前，务必备份 cacerts 文件，以防万一。

      cp $JAVA_HOME/jre/lib/security/cacerts $JAVA_HOME/jre/lib/security/cacerts.bak

    • 导入服务器证书到 cacerts: 使用 keytool 命令将服务器证书导入到 cacerts 中：

      keytool -import -trustcacerts -alias your_alias -file server.crt -keystore $JAVA_HOME/jre/lib/security/cacerts -storepass changeit
      • your_alias 是一个你自定义的别名，用于标识这个证书。
      • server.crt 是你保存的服务器证书文件。
      • changeit 是 cacerts 文件的默认密码。 在生产环境中，强烈建议更改这个默认密码。

    • 验证证书是否成功导入: 使用 keytool 命令列出 cacerts 中的证书：

      keytool -list -keystore $JAVA_HOME/jre/lib/security/cacerts -storepass changeit

      确认你导入的证书是否在列表中。

  4. 重新启动应用程序:

    • 在更新了 cacerts 文件后，需要重新启动你的 Java 应用程序，才能使更改生效。

4. 代码示例

下面是一个使用 HttpsURLConnection 连接到使用了自签名证书的服务器的示例代码：

import javax.net.ssl.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;

public class HttpsClient {

    public static void main(String[] args) throws Exception {

        // 创建一个信任所有证书的 TrustManager
        TrustManager[] trustAllCerts = new TrustManager[] {
                new X509TrustManager() {
                    public java.security.cert.X509Certificate[] getAcceptedIssuers() {
                        return null;
                    }
                    public void checkClientTrusted(X509Certificate[] certs, String authType) {}
                    public void checkServerTrusted(X509Certificate[] certs, String authType) throws CertificateException {}
                }
        };

        // 安装 TrustManager
        SSLContext sc = SSLContext.getInstance("SSL");
        sc.init(null, trustAllCerts, new java.security.SecureRandom());
        HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());

        // 创建一个信任所有主机名的 HostnameVerifier
        HostnameVerifier allHostsValid = (hostname, session) -> true;

        // 安装 HostnameVerifier
        HttpsURLConnection.setDefaultHostnameVerifier(allHostsValid);

        // 连接到 HTTPS 服务器
        URL url = new URL("https://yourdomain.com"); // 替换为你的 HTTPS 服务器地址
        HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();

        // 获取响应
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            connection.disconnect();
        }
    }
}

注意: 上述代码使用了一个信任所有证书和所有主机名的 TrustManager 和 HostnameVerifier。 这在生产环境中是非常不安全的，因为它可以绕过所有的证书验证。 这种方式只应该用于测试和开发环境。

在生产环境中，应该使用正确的根证书来验证服务器证书的有效性。

5. 使用 HTTP 客户端库 (HttpClient, OkHttp) 解决 SSLHandshakeException

除了使用 HttpsURLConnection，还可以使用一些流行的 HTTP 客户端库，例如 Apache HttpClient 和 OkHttp。 这些库提供了更方便的 API 和更多的配置选项。

Apache HttpClient:

import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.ssl.SSLContextBuilder;

import javax.net.ssl.SSLContext;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class HttpClientExample {

    public static void main(String[] args) throws Exception {

        // 创建一个信任所有证书的 SSLContext
        SSLContext sslContext = new SSLContextBuilder()
                .loadTrustMaterial(null, (certificate, authType) -> true)
                .build();

        // 创建一个 SSLConnectionSocketFactory，使用信任所有证书的 SSLContext 和 NoopHostnameVerifier
        SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
                sslContext,
                NoopHostnameVerifier.INSTANCE);

        // 创建一个 HttpClient，使用 SSLConnectionSocketFactory
        CloseableHttpClient httpClient = HttpClients.custom()
                .setSSLSocketFactory(sslsf)
                .build();

        try {
            // 创建一个 HttpGet 请求
            HttpGet httpGet = new HttpGet("https://yourdomain.com"); // 替换为你的 HTTPS 服务器地址

            // 执行请求
            CloseableHttpResponse response = httpClient.execute(httpGet);

            // 获取响应
            try (BufferedReader reader = new BufferedReader(new InputStreamReader(response.getEntity().getContent()))) {
                String line;
                while ((line = reader.readLine()) != null) {
                    System.out.println(line);
                }
            } finally {
                response.close();
            }
        } finally {
            httpClient.close();
        }
    }
}

OkHttp:

import okhttp3.*;

import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import java.io.IOException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;

public class OkHttpExample {

    public static void main(String[] args) throws Exception {

        // 创建一个信任所有证书的 TrustManager
        TrustManager[] trustAllCerts = new TrustManager[] {
                new X509TrustManager() {
                    @Override
                    public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
                    }

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

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

        // 创建一个 SSLContext，使用信任所有证书的 TrustManager
        SSLContext sslContext = SSLContext.getInstance("SSL");
        sslContext.init(null, trustAllCerts, new java.security.SecureRandom());

        // 获取 SSLSocketFactory
        SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory();

        // 创建一个 OkHttpClient，禁用证书验证
        OkHttpClient client = new OkHttpClient.Builder()
                .sslSocketFactory(sslSocketFactory, (X509TrustManager)trustAllCerts[0])
                .hostnameVerifier((hostname, session) -> true)
                .build();

        // 创建一个 Request
        Request request = new Request.Builder()
                .url("https://yourdomain.com") // 替换为你的 HTTPS 服务器地址
                .build();

        // 执行请求
        try (Response response = client.newCall(request).execute()) {
            if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

            // 获取响应
            System.out.println(response.body().string());
        }
    }
}

同样需要注意的是，以上使用 HttpClient 和 OkHttp 的代码示例也使用了信任所有证书的方式，仅适用于测试和开发环境。 在生产环境中，请使用正确的根证书进行验证。

6. 总结与最佳实践

总而言之，解决 SSLHandshakeException 的关键在于理解 SSL/TLS 握手流程，定位问题的根源，并采取相应的措施。通常，更新 Java 的信任证书库 cacerts 可以解决由于缺少根证书导致的 SSLHandshakeException。

最佳实践：

  • 始终使用最新的 JDK 版本: 新的 JDK 版本通常包含最新的根证书。
  • 定期更新 cacerts 文件: 可以使用 keytool 命令手动更新 cacerts 文件，或者使用一些自动化工具来定期更新。
  • 避免使用信任所有证书的方式: 在生产环境中，绝对不要使用信任所有证书的 TrustManager 和 HostnameVerifier。
  • 使用专业的证书管理工具: 可以使用专业的证书管理工具来管理你的证书，例如 Let’s Encrypt。
  • 监控证书过期时间: 定期监控服务器证书的过期时间，并及时更新证书。

7. 使用编程方式添加信任证书

除了更新 cacerts 文件，还可以使用编程方式添加信任证书。 这种方式更加灵活，可以针对特定的 API 使用特定的证书，而不需要修改全局的 cacerts 文件。

import javax.net.ssl.*;
import java.io.FileInputStream;
import java.io.IOException;
import java.security.*;
import java.security.cert.Certificate;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;

public class AddCertificateProgrammatically {

    public static void main(String[] args) throws Exception {

        String certificatePath = "server.crt"; // 替换为你的证书文件路径
        String urlString = "https://yourdomain.com"; // 替换为你的 HTTPS 服务器地址

        // 1. 加载证书
        CertificateFactory cf = CertificateFactory.getInstance("X.509");
        Certificate ca;
        try (FileInputStream fis = new FileInputStream(certificatePath)) {
            ca = cf.generateCertificate(fis);
        }

        // 2. 创建 KeyStore
        KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
        keyStore.load(null, null); // 初始化 KeyStore
        keyStore.setCertificateEntry("your_alias", ca); // 添加证书到 KeyStore

        // 3. 创建 TrustManagerFactory
        TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
        tmf.init(keyStore); // 使用 KeyStore 初始化 TrustManagerFactory

        // 4. 创建 SSLContext
        SSLContext sslContext = SSLContext.getInstance("TLS");
        sslContext.init(null, tmf.getTrustManagers(), new SecureRandom()); // 使用 TrustManager 初始化 SSLContext

        // 5. 设置 HttpsURLConnection 的 SSLSocketFactory
        HttpsURLConnection.setDefaultSSLSocketFactory(sslContext.getSocketFactory());

        // 6. 连接到 HTTPS 服务器
        URL url = new URL(urlString);
        HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();

        // 7. 获取响应
        try (java.io.BufferedReader reader = new java.io.BufferedReader(new java.io.InputStreamReader(connection.getInputStream()))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            connection.disconnect();
        }
    }
}

这段代码演示了如何从证书文件中加载证书，创建一个 KeyStore，并使用这个 KeyStore 创建一个 TrustManagerFactory 和 SSLContext。 然后，将 SSLContext 设置为 HttpsURLConnection 的默认 SSLSocketFactory，从而使 HttpsURLConnection 使用自定义的信任证书。

8. 总结重点，采取安全可靠的方案

总结一下，解决 SSLHandshakeException 的关键在于理解证书链的验证过程，并确保客户端拥有服务器证书链中所有必要的证书。 更新 cacerts 文件是一种通用的解决方案，而编程方式添加信任证书则更加灵活。 在生产环境中，应该始终使用安全可靠的方案，避免使用信任所有证书的方式。并且定期监控证书的有效性，保证数据传输的安全性。

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注