Java HTTPS客户端证书认证

Question

Java HTTPS客户端证书认证

272

我对 HTTPS/SSL/TLS 相当陌生，不是很清楚客户端在使用证书进行身份验证时应该呈现什么。

我正在编写一个需要向特定 URL 发送数据的 Java 客户端。这部分工作已经完成，唯一的问题是需要使用 HTTPS 进行。处理 HTTPS 部分相当容易（可以使用 HTTPclient 或者使用 Java 内置的 HTTPS 支持），但是我卡在了使用客户端证书进行身份验证上。我注意到这里已经有一个非常类似的问题，但我还没有尝试将其与我的代码结合起来解决（很快会做）。我当前的问题是，无论我做什么，Java 客户端都不会发送证书（我可以使用 PCAP 转储检查这一点）。

我想知道客户端在使用证书进行身份验证时应该向服务器呈现什么（特别是对于 Java - 如果这很重要的话）？这是一个 JKS 文件，还是 PKCS#12？它们中应该放什么; 只有客户端证书，还是密钥？如果是这样，哪个密钥？所有不同类型的文件、证书类型之间有很多混淆。

正如我之前所说，我对 HTTPS/SSL/TLS 还不熟悉，所以我也想了解一些背景信息（不需要写得很详细；如果能给我好文章的链接我会很满意）。

- tmbrggmn

我从客户那里得到了两个证书，如何确定哪一个需要添加到密钥库和信任库中？由于您已经遇到过类似的问题，请帮忙解决这个问题。实际上，我提出了这个问题，但是我不知道该怎么做。https://stackoverflow.com/questions/61374276/access-https-restful-service-using-web-client-in-spring-boot-2-0-throwing-except - henrycharles

9个回答

104

其他答案展示了如何全局配置客户端证书。但是，如果您想为一个特定的连接编程定义客户端密钥，而不是在JVM上的每个应用程序中全局定义它，那么您可以像这样配置自己的SSLContext：

String keyPassphrase = "";

KeyStore keyStore = KeyStore.getInstance("PKCS12");
keyStore.load(new FileInputStream("cert-key-pair.pfx"), keyPassphrase.toCharArray());

SSLContext sslContext = SSLContexts.custom()
        .loadKeyMaterial(keyStore, null)
        .build();

HttpClient httpClient = HttpClients.custom().setSSLContext(sslContext).build();
HttpResponse response = httpClient.execute(new HttpGet("https://example.com"));

- Magnus

5

“信任材料”是指客户端信任远程服务器证书的内容，“密钥材料”是指服务器信任客户端的内容。” - Magnus

4

我很喜欢这个简明扼要的回答。如果有人感兴趣，我在这里提供了一个带有构建说明的示例： https://dev59.com/wHbZa4cB1Zd3GeqPEVBR#46821977 - Alain O'Dea

7

你救了我的一天！我只需要再做一个额外的更改，就是在 loadKeyMaterial(keystore, keyPassphrase.toCharArray()) 代码中也发送密码！ - AnandShanbhag

1

这个答案不是特定于Apache HttpClient吗？ - peterh

2

@peterh 是的，它是特定于Apache http的。每个HTTP库都有自己的配置方式，但大多数库应该都会使用SSLContext。 - Magnus

显示剩余2条评论

35

JKS文件只是证书和密钥对的容器。

在客户端身份验证场景中，密钥的各个部分将位于以下位置：

客户端存储库将包含客户端的私有和公共密钥对。它被称为密钥库。
服务器存储库将包含客户端的公共密钥。它被称为信任库。

分离信任库和密钥库并非强制要求，但建议这样做。它们可以是同一个物理文件。

要设置两个存储库的文件系统位置，请使用以下系统属性：

-Djavax.net.ssl.keyStore=clientsidestore.jks

并且在服务器上：

-Djavax.net.ssl.trustStore=serversidestore.jks

要将客户端的证书（公钥）导出到文件中，以便您可以将其复制到服务器上，请使用：

keytool -export -alias MYKEY -file publicclientkey.cer -store clientsidestore.jks

要将客户端的公钥导入服务器的密钥库中，请使用以下命令（如发帖者所述，此步骤已由服务器管理员完成）

keytool -import -file publicclientkey.cer -store serversidestore.jks

- mhaller

1

我应该提到我对服务器没有控制权。服务器已经导入了我们的公共证书。那个系统的管理员告诉我，我需要明确提供证书，以便在握手期间将其发送（他们的服务器明确要求这样做）。 - tmbrggmn

您需要一个公钥和私钥以创建一个JKS文件供服务器使用，用于生成公共证书（即已知于服务器）。 - sfussenegger

感谢提供示例代码。在上面的代码中，“mykey-public.cer”是什么？这是客户端公共证书吗（我们使用自签名证书）？ - tmbrggmn

是的，我已经相应地在代码片段中重命名了文件。希望这样更清楚明白。 - mhaller

好的，谢谢。我经常会感到困惑，因为似乎“key”和“certificate”是可以互换使用的。 - tmbrggmn

显示剩余2条评论

14

Maven 的 pom.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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>some.examples</groupId>
    <artifactId>sslcliauth</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <name>sslcliauth</name>
    <dependencies>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.4</version>
        </dependency>
    </dependencies>
</project>

Java 代码：

package some.examples;

import java.io.FileInputStream;
import java.io.IOException;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.CertificateException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.net.ssl.SSLContext;
import org.apache.http.HttpEntity;
import org.apache.http.HttpHost;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.ssl.SSLContexts;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.apache.http.entity.InputStreamEntity;

public class SSLCliAuthExample {

private static final Logger LOG = Logger.getLogger(SSLCliAuthExample.class.getName());

private static final String CA_KEYSTORE_TYPE = KeyStore.getDefaultType(); //"JKS";
private static final String CA_KEYSTORE_PATH = "./cacert.jks";
private static final String CA_KEYSTORE_PASS = "changeit";

private static final String CLIENT_KEYSTORE_TYPE = "PKCS12";
private static final String CLIENT_KEYSTORE_PATH = "./client.p12";
private static final String CLIENT_KEYSTORE_PASS = "changeit";

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

public final static void requestTimestamp() throws Exception {
    SSLConnectionSocketFactory csf = new SSLConnectionSocketFactory(
            createSslCustomContext(),
            new String[]{"TLSv1"}, // Allow TLSv1 protocol only
            null,
            SSLConnectionSocketFactory.getDefaultHostnameVerifier());
    try (CloseableHttpClient httpclient = HttpClients.custom().setSSLSocketFactory(csf).build()) {
        HttpPost req = new HttpPost("https://changeit.com/changeit");
        req.setConfig(configureRequest());
        HttpEntity ent = new InputStreamEntity(new FileInputStream("./bytes.bin"));
        req.setEntity(ent);
        try (CloseableHttpResponse response = httpclient.execute(req)) {
            HttpEntity entity = response.getEntity();
            LOG.log(Level.INFO, "*** Reponse status: {0}", response.getStatusLine());
            EntityUtils.consume(entity);
            LOG.log(Level.INFO, "*** Response entity: {0}", entity.toString());
        }
    }
}

public static RequestConfig configureRequest() {
    HttpHost proxy = new HttpHost("changeit.local", 8080, "http");
    RequestConfig config = RequestConfig.custom()
            .setProxy(proxy)
            .build();
    return config;
}

public static SSLContext createSslCustomContext() throws KeyStoreException, IOException, NoSuchAlgorithmException, CertificateException, KeyManagementException, UnrecoverableKeyException {
    // Trusted CA keystore
    KeyStore tks = KeyStore.getInstance(CA_KEYSTORE_TYPE);
    tks.load(new FileInputStream(CA_KEYSTORE_PATH), CA_KEYSTORE_PASS.toCharArray());

    // Client keystore
    KeyStore cks = KeyStore.getInstance(CLIENT_KEYSTORE_TYPE);
    cks.load(new FileInputStream(CLIENT_KEYSTORE_PATH), CLIENT_KEYSTORE_PASS.toCharArray());

    SSLContext sslcontext = SSLContexts.custom()
            //.loadTrustMaterial(tks, new TrustSelfSignedStrategy()) // use it to customize
            .loadKeyMaterial(cks, CLIENT_KEYSTORE_PASS.toCharArray()) // load client certificate
            .build();
    return sslcontext;
}

}

- kinjelom

如果您希望证书对所有使用特定JVM安装的应用程序都可用，请按照此答案的说明操作。 - ADTC

客户端项目中设置代理的方法configureRequest()是否正确？ - shareef

是的，这是HTTP客户端配置，并且在这种情况下是代理配置。 - kinjelom

也许我有一个愚蠢的问题，但是我该如何创建一个名为cacert.jks的文件？我遇到了异常Exception in thread "main" java.io.FileNotFoundException: .\cacert.jks（系统找不到指定的文件）。 - Patlatus

10

假设你有一个包含证书和私钥（例如使用openssl生成的）的p12文件，下面的代码将用于特定的HttpsURLConnection：

    KeyStore keyStore = KeyStore.getInstance("pkcs12");
    keyStore.load(new FileInputStream(keyStorePath), keystorePassword.toCharArray());
    KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
    kmf.init(keyStore, keystorePassword.toCharArray());
    SSLContext ctx = SSLContext.getInstance("TLS");
    ctx.init(kmf.getKeyManagers(), null, null);
    SSLSocketFactory sslSocketFactory = ctx.getSocketFactory();

    HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
    connection.setSSLSocketFactory(sslSocketFactory);

< p > SSLContext 需要一些时间来初始化，因此您可能希望将其缓存。

- Johannes Brodwall

6

如果您只想设置双向身份验证（服务器和客户端证书），这两个链接的组合将帮助您实现：

双向身份认证设置：

https://linuxconfig.org/apache-web-server-ssl-authentication

您不需要使用他们提到的openssl配置文件；只需使用

$ openssl genrsa -des3 -out ca.key 4096
$ openssl req -new -x509 -days 365 -key ca.key -out ca.crt

生成自己的CA证书，然后通过以下方式生成和签署服务器和客户端密钥：

$ openssl genrsa -des3 -out server.key 4096
$ openssl req -new -key server.key -out server.csr
$ openssl x509 -req -days 365 -in server.csr -CA ca.crt -CAkey ca.key -set_serial 100 -out server.crt

和

$ openssl genrsa -des3 -out client.key 4096
$ openssl req -new -key client.key -out client.csr
$ openssl x509 -req -days 365 -in client.csr -CA ca.crt -CAkey ca.key -set_serial 101 -out client.crt

其余步骤请查看链接。Chrome证书管理与所提到的Firefox示例相同。

接下来，通过以下方式设置服务器：

https://www.digitalocean.com/community/tutorials/how-to-create-a-ssl-certificate-on-apache-for-ubuntu-14-04

请注意，您已经创建了服务器.crt和.key文件，因此无需再执行此步骤。

- hans

1

你在服务器CSR生成步骤中可能打错了字：应该使用server.key而不是client.key。 - the.Legend

3

有一个比手动导航到 https://url，知道在哪个浏览器中点击哪个按钮，知道在何处以及如何保存“证书”文件，最后知道使用 keytool 进行本地安装的魔术咒语更好的方法。

只需执行以下操作：

将下面的代码保存为 InstallCert.java
打开命令行并执行：javac InstallCert.java
运行命令：java InstallCert <host>[:port] [passphrase]（端口和密码是可选的）

以下是 InstallCert 的代码，请注意头部中的年份，可能需要针对“较新”的 Java 版本进行修改：

/*
 * Copyright 2006 Sun Microsystems, Inc.  All Rights Reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   - Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *
 *   - Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *
 *   - Neither the name of Sun Microsystems nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

import java.io.*;
import java.net.URL;

import java.security.*;
import java.security.cert.*;

import javax.net.ssl.*;

public class InstallCert {

    public static void main(String[] args) throws Exception {
  String host;
  int port;
  char[] passphrase;
  if ((args.length == 1) || (args.length == 2)) {
      String[] c = args[0].split(":");
      host = c[0];
      port = (c.length == 1) ? 443 : Integer.parseInt(c[1]);
      String p = (args.length == 1) ? "changeit" : args[1];
      passphrase = p.toCharArray();
  } else {
      System.out.println("Usage: java InstallCert <host>[:port] [passphrase]");
      return;
  }

  File file = new File("jssecacerts");
  if (file.isFile() == false) {
      char SEP = File.separatorChar;
      File dir = new File(System.getProperty("java.home") + SEP
        + "lib" + SEP + "security");
      file = new File(dir, "jssecacerts");
      if (file.isFile() == false) {
    file = new File(dir, "cacerts");
      }
  }
  System.out.println("Loading KeyStore " + file + "...");
  InputStream in = new FileInputStream(file);
  KeyStore ks = KeyStore.getInstance(KeyStore.getDefaultType());
  ks.load(in, passphrase);
  in.close();

  SSLContext context = SSLContext.getInstance("TLS");
  TrustManagerFactory tmf =
      TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
  tmf.init(ks);
  X509TrustManager defaultTrustManager = (X509TrustManager)tmf.getTrustManagers()[0];
  SavingTrustManager tm = new SavingTrustManager(defaultTrustManager);
  context.init(null, new TrustManager[] {tm}, null);
  SSLSocketFactory factory = context.getSocketFactory();

  System.out.println("Opening connection to " + host + ":" + port + "...");
  SSLSocket socket = (SSLSocket)factory.createSocket(host, port);
  socket.setSoTimeout(10000);
  try {
      System.out.println("Starting SSL handshake...");
      socket.startHandshake();
      socket.close();
      System.out.println();
      System.out.println("No errors, certificate is already trusted");
  } catch (SSLException e) {
      System.out.println();
      e.printStackTrace(System.out);
  }

  X509Certificate[] chain = tm.chain;
  if (chain == null) {
      System.out.println("Could not obtain server certificate chain");
      return;
  }

  BufferedReader reader =
    new BufferedReader(new InputStreamReader(System.in));

  System.out.println();
  System.out.println("Server sent " + chain.length + " certificate(s):");
  System.out.println();
  MessageDigest sha1 = MessageDigest.getInstance("SHA1");
  MessageDigest md5 = MessageDigest.getInstance("MD5");
  for (int i = 0; i < chain.length; i++) {
      X509Certificate cert = chain[i];
      System.out.println
        (" " + (i + 1) + " Subject " + cert.getSubjectDN());
      System.out.println("   Issuer  " + cert.getIssuerDN());
      sha1.update(cert.getEncoded());
      System.out.println("   sha1    " + toHexString(sha1.digest()));
      md5.update(cert.getEncoded());
      System.out.println("   md5     " + toHexString(md5.digest()));
      System.out.println();
  }

  System.out.println("Enter certificate to add to trusted keystore or 'q' to quit: [1]");
  String line = reader.readLine().trim();
  int k;
  try {
      k = (line.length() == 0) ? 0 : Integer.parseInt(line) - 1;
  } catch (NumberFormatException e) {
      System.out.println("KeyStore not changed");
      return;
  }

  X509Certificate cert = chain[k];
  String alias = host + "-" + (k + 1);
  ks.setCertificateEntry(alias, cert);

  OutputStream out = new FileOutputStream("jssecacerts");
  ks.store(out, passphrase);
  out.close();

  System.out.println();
  System.out.println(cert);
  System.out.println();
  System.out.println
    ("Added certificate to keystore 'jssecacerts' using alias '"
    + alias + "'");
    }

    private static final char[] HEXDIGITS = "0123456789abcdef".toCharArray();

    private static String toHexString(byte[] bytes) {
  StringBuilder sb = new StringBuilder(bytes.length * 3);
  for (int b : bytes) {
      b &= 0xff;
      sb.append(HEXDIGITS[b >> 4]);
      sb.append(HEXDIGITS[b & 15]);
      sb.append(' ');
  }
  return sb.toString();
    }

    private static class SavingTrustManager implements X509TrustManager {

  private final X509TrustManager tm;
  private X509Certificate[] chain;

  SavingTrustManager(X509TrustManager tm) {
      this.tm = tm;
  }

  public X509Certificate[] getAcceptedIssuers() {
      throw new UnsupportedOperationException();
  }

  public void checkClientTrusted(X509Certificate[] chain, String authType)
    throws CertificateException {
      throw new UnsupportedOperationException();
  }

  public void checkServerTrusted(X509Certificate[] chain, String authType)
    throws CertificateException {
      this.chain = chain;
      tm.checkServerTrusted(chain, authType);
  }
    }

}

- niken

由于我是一个喜欢让懒人阅读和修改代码的粉丝，如果你想下载整个“链”（这绝对是使SSL身份验证在公司代理后面工作所必需的），你只需要在上面的代码中添加一个循环，循环遍历该链并将其写入cacerts或jssecacerts或其他文件中（你自己想办法）。 - niken

2

我已经使用Spring Boot双向SSL（客户端和服务器证书）连接到银行。这里描述了我所有的步骤，希望能帮助到某些人（这是我找到的最简单的工作解决方案）：

生成证书请求：

Generate private key:

     openssl genrsa -des3 -passout pass:MY_PASSWORD -out user.key 2048

Generate certificate request:

     openssl req -new -key user.key -out user.csr -passin pass:MY_PASSWORD

保留user.key（和密码），并向银行发送证书请求。

Receive 2 certificate: my client root certificate user.pem and bank root certificate: bank.crt
Create Java keystore (enter key password and set keystore password):
```
openssl pkcs12 -export -in user.pem -inkey user.key -out keystore.p12 -name clientId -CAfile ca.crt -caname root
```
Don't pay attention on output: unable to write 'random state'. Java PKCS12 keystore.p12 created.

Add into keystore bank.crt (for simplicity I've used one keystore):

keytool -import -alias bankca -file bank.crt -keystore keystore.p12 -storepass MY_PASS

Check keystore certificates by:

keytool -list -keystore keystore.p12

Ready for Java code:) I've used Spring Boot RestTemplate with add org.apache.httpcomponents.httpcore dependency:

@Bean("sslRestTemplate")
public RestTemplate sslRestTemplate() throws Exception {
  char[] storePassword = appProperties.getSslStorePassword().toCharArray();
  URL keyStore = new URL(appProperties.getSslStore());

  SSLContext sslContext = new SSLContextBuilder()
        .loadTrustMaterial(keyStore, storePassword)
  // use storePassword twice (with key password do not work)!!
        .loadKeyMaterial(keyStore, storePassword, storePassword) 
        .build();

  // Solve "Certificate doesn't match any of the subject alternative names"
  SSLConnectionSocketFactory socketFactory = new SSLConnectionSocketFactory(sslContext, NoopHostnameVerifier.INSTANCE);

  CloseableHttpClient client = HttpClients.custom().setSSLSocketFactory(socketFactory).build();
  HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory(client);
  RestTemplate restTemplate = new RestTemplate(factory);
  // restTemplate.setMessageConverters(List.of(new Jaxb2RootElementHttpMessageConverter()));
  return restTemplate;
}

- Grigory Kislin

你可以使用keytool完成所有操作，完全不需要OpenSSL。 - user207421

这个答案太棒了！！！非常感谢 :) - Saikat

这个回答真是太棒了！！非常感谢 :) - undefined

-1

我认为这里的修复是密钥库类型，pkcs12(pfx)总是有私钥，而JKS类型可以存在没有私钥的情况。除非您在代码中指定或通过浏览器选择证书，否则服务器无法知道它代表另一端的客户端。

- ObiWanKenobi

1

PKCS12格式传统上用于私钥和证书，但自2014年Java 8以来（比本答案早一年多），已支持包含证书而不包含私钥的PKCS12。无论密钥库格式如何，客户端身份验证都需要私钥和证书。我不理解你的第二句话，但是如果至少有一个合适的条目可用，或者可以配置密钥管理器使用指定的条目，Java客户端可以自动选择客户端证书和密钥。 - dave_thompson_085

1

你的第二句话完全是错误的。服务器提供其可信签名，客户端要么中断连接，要么不提供满足该约束条件的证书。这个过程是自动完成的，而非通过“在代码中”实现。这就是服务器“知道它正在代表一个客户端”的方式。 - user207421

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- tmbrggmn · Accepted Answer

最终成功解决了所有问题，所以我会回答自己的问题。这些是我用来解决我的特定问题的设置/文件;

客户端密钥库 是一个包含 PKCS#12格式 的文件，其中包含：

客户端的公共证书（此实例中由自签名 CA 签名）
客户端的私有密钥

我使用 OpenSSL 的 pkcs12 命令生成它，例如;

openssl pkcs12 -export -in client.crt -inkey client.key -out client.p12 -name "Whatever"

提示: 请确保您获取了最新的OpenSSL版本，而不是0.9.8h版本，因为该版本似乎存在一个错误，无法正确生成PKCS#12文件。

这个PKCS#12文件将被Java客户端用来在服务器明确要求客户端进行身份验证时向服务器提供客户端证书。有关客户端证书认证协议实际如何工作的概述，请参阅维基百科TLS文章(同时解释了为什么我们需要在这里使用客户端的私钥)。

客户端信任库(truststore)是一个包含根证书或中间CA证书的直接JKS格式文件。这些CA证书将决定您可以与哪些端点通信，在此情况下，它将允许您的客户端连接到由信任库中的一个CA签名的证书的任何服务器。

您可以使用标准的Java keytool来生成它，例如;

keytool -genkey -dname "cn=CLIENT" -alias truststorekey -keyalg RSA -keystore ./client-truststore.jks -keypass whatever -storepass whatever
keytool -import -keystore ./client-truststore.jks -file myca.crt -alias myca

使用此信任库，您的客户端将尝试与所有提供由myca.crt标识的 CA 签名证书的服务器进行完整的 SSL 握手。

上面的文件严格仅适用于客户端。当您还想要设置服务器时，服务器需要其自己的密钥和信任库文件。有一个很好的详细步骤，可以为 Java 客户端和服务器（使用 Tomcat）设置一个完全可工作的示例，在此网站上可以找到。

问题/备注/提示

只有服务器才能强制要求 客户端证书认证。
(重要！) 当服务器请求客户端证书（作为 TLS 握手的一部分）时，它还将提供可信的 CA 列表作为证书请求的一部分。当您希望用于身份验证的客户端证书未由这些 CA 之一签名时，它根本不会被呈现（在我看来，这是奇怪的行为，但我相信有理由）。这是我的主要问题的原因，因为另一方未正确配置其服务器以接受我自签名的客户端证书，而我们认为问题出在我这里，因为我没有在请求中正确提供客户端证书。
获取 Wireshark。它具有出色的 SSL/HTTPS 包分析功能，并将在调试和查找问题时提供巨大帮助。它类似于 -Djavax.net.debug=ssl，但更结构化且（可以说）更容易理解，如果您对 Java SSL 调试输出感到不适，则可以使用它。

完全可以使用 Apache HttpClient 库。如果您想要使用 httpclient，请将目标 URL 替换为 HTTPS 等效项，并添加以下 JVM 参数（对于任何其他客户端都是相同的，无论您要使用哪个库来发送/接收 HTTP/HTTPS 数据）：

-Djavax.net.debug=ssl
-Djavax.net.ssl.keyStoreType=pkcs12
-Djavax.net.ssl.keyStore=client.p12
-Djavax.net.ssl.keyStorePassword=whatever
-Djavax.net.ssl.trustStoreType=jks
-Djavax.net.ssl.trustStore=client-truststore.jks
-Djavax.net.ssl.trustStorePassword=whatever