为高级 JSSE 开发人员定制 SSL_中国IT运维网www.cnitom.com

当数据在网络上传播的时候，通过使用 SSL 对其进行加密和保护，JSSE 为 Java 应用程序提供了安全的通信。在本篇有关该技术的高级研究中，Java 中间件开发人员 Ian Parkinson 深入研究了 JSSE API 较不为人知的方面，为您演示了如何围绕 SSL 的一些限制进行编程。您将学习如何动态地选择 KeyStore 和 TrustStore、放宽 JSSE 的密码匹配要求，以及构建您自己定制的 KeyManager 实现。

JSSE（Java 安全套接字扩展，Java Secure Socket Extension）使 Java 应用程序能够在因特网上使用 SSL 安全地进行通信。由于 developerWorks 已经提供了一篇涵盖 JSSE 基本用法的教程，所以本文将集中阐述该技术的更高级用法。本文将演示如何使用 JSSE 接口定制 SSL 连接的属性。

首先，我们将开发一个非常简单的安全客户机／服务器聊天应用程序。在我们构建该程序的客户机端时，我将演示如何定制 KeyStore 和 TrustStore 文件，以便从客户机的文件系统装入它们。接着，我们将着重说明证书和标识。通过从 KeyStore 选择不同的证书，可以将客户机以不同的形式提供给不同的服务器。如果您的客户机应用程序需要连接到多个对等方，或者甚至它需要冒充不同的用户，这项高级的功能都特别有用。

由于本文着重讲述更高级的主题，因此假定您已经具备了 JSSE 的使用经验。要运行示例，需要一个带有正确安装和配置 JSSE 提供程序的 Java SDK。J2SE 1.4 SDK 提供了已安装和配置的 JSSE。如果您正在使用 J2SE 1.2 或 1.3，则需要获取一个 JSSE 实现并安装它。

JSSE API 只是 J2SE 1.4 的一项标准，并且早期的 JSSE 实现之间存在略有不同的变体。本文的示例基于 1.4 API。必要的时候，我会强调使示例与 J2SE 1.2 和 1.3 的 Sun JSSE 实现协同工作所必需的更改。

入门：设置
在我们深入研究 JSSE 之前，先让我们熟悉一下将要使用的客户机／服务器应用程序。SimpleSSLServer 和 SimpleSSLClient 是我们的演示应用程序的两个组件。为了运行示例，需要在应用程序的每一端上设置好几个 KeyStore 和 TrustStore 文件。特别是您将需要：

接下来，下载本文随附的 jar 文件。这些文件包含客户机／服务器应用程序的源代码和已编译的版本，因此，只要把它们放到 CLASSPATH 中，就可以使用了。

建立一个安全连接
要运行 SimpleSSLServer，我们输入如下（稍微冗长的）命令：


java -Djavax.net.ssl.keyStore=serverKeys 
  -Djavax.net.ssl.keyStorePassword=password 
  -Djavax.net.ssl.trustStore=serverTrust 
  -Djavax.net.ssl.trustStorePassword=password SimpleSSLServer

可以看到，我们已指定了 KeyStore，用它来标识服务器，还指定了在 KeyStore 中设置的密码。由于服务器将需要客户机认证，因此我们也为它提供了 TrustStore。通过指定 TrustStore，我们确保 SSLSimpleServer 将信任由 SSLSimpleClient 提供的证书。服务器初始化它自己后，您将得到下述报告：

 
SimpleSSLServer running on port 49152

之后，服务器将等待来自客户机的连接。如果希望在另一个端口上运行服务器，在命令的结尾处指定，用选定的端口代替变量。

接下来，设置应用程序的客户机组件。从另一个控制台窗口输入如下命令：


java -Djavax.net.ssl.keyStore=clientKeys 
  -Djavax.net.ssl.keyStorePassword=password 
  -Djavax.net.ssl.trustStore=clientTrust 
  -Djavax.net.ssl.trustStorePassword=password SimpleSSLClient

缺省情况下，客户机将尝试连接到运行在本地主机端口 49152 上的服务器。可以在命令行上使用和参数更改主机。当客户机已连接到服务器时，您会得到消息：


Connected

与此同时，服务器将报告连接请求，并显示由客户机提供的区别名，如下所示：


1: New connection request
1: Request from CN=Bob, OU=developerWorks, O=IBM, L=Winchester, 
       ST=Hampshire, C=UK

为了测试新连接，试着向客户机输入一些文本，按 Return 键，并观察服务器是否回显文本。要杀死客户机，在客户机控制台上按 Ctrl-C 键。服务器将如下所示记录断开连接：


1: Client disconnected

无需杀死服务器；在各种练习过程中我们只需保持服务器运行。

SimpleSSLServer 内幕
尽管本文余下部分主要都是讲述客户机应用程序的，但是，查看一下服务器代码仍然是很值得的。除了可以了解服务器应用程序是如何工作外，您还可以学会如何使用接口检索有关 SSL 连接的信息。

从三条 import 语句开始，如下所示：


import javax.net.ssl.*;
import java.security.cert.*;
import java.io.*;

接下来，方法检查命令行中可选的参数。然后它获取缺省的，构造一个对象，把工厂（factory）传递给构造器，并且启动服务器，如下所示：


SSLServerSocketFactory ssf=
  (SSLServerSocketFactory)SSLServerSocketFactory.getDefault();
SimpleSSLServer server=new SimpleSSLServer(ssf, port);
server.start();

由于服务器是在单独的线程上运行的，因此只要启动并运行，就退出。新的线程调用方法，这样会创建一个，并且设置服务器以要求客户机认证，如下所示：


SSLServerSocket serverSocket=
  (SSLServerSocket)serverSocketFactory.createServerSocket(port);
serverSocket.setNeedClientAuth(true);

HandshakeCompletedListener
将它激活之后，方法进行无限循环，等待来自客户机的请求。每个套接字都与实现相关联，后者用来显示来自客户机证书的区别名（DN）。套接字的封装在一个中，它作为另一个线程运行，并且将来自套接字的数据回显到。SimpleSSLServer 的主循环如清单 1 所示：

清单 1. SimpleSSLServer 主循环


while (true) {
  String ident=String.valueOf(id++);

  // Wait for a connection request.
  SSLSocket socket=(SSLSocket)serverSocket.accept();

  // We add in a HandshakeCompletedListener, which allows us to
  // peek at the certificate provided by the client.
  HandshakeCompletedListener hcl=new SimpleHandshakeListener(ident);
  socket.addHandshakeCompletedListener(hcl);

  InputStream in=socket.getInputStream();
  new InputDisplayer(ident, in);
}

我们的 ― 提供了一个方法的实现。当 SSL 握手阶段完成时，该方法由 JSSE 基础设施调用，并且传递（在对象中）有关连接的信息。我们使用这个方法获取并显示客户机的 DN，如清单 2 所示：

清单 2. SimpleHandshakeListener


class SimpleHandshakeListener implements HandshakeCompletedListener
{
  String ident;

  /**

   * Constructs a SimpleHandshakeListener with the given
   * identifier.
   * @param ident Used to identify output from this Listener.
   */
  public SimpleHandshakeListener(String ident)
  {
    this.ident=ident;
  }

  /** Invoked upon SSL handshake completion. */
  public void handshakeCompleted(HandshakeCompletedEvent event)
  {
    // Display the peer specified in the certificate.
    try {
      X509Certificate 
        cert=(X509Certificate)event.getPeerCertificates()[0];
      String peer=cert.getSubjectDN().getName();
      System.out.println(ident+": Request from "+peer);
    }
    catch (SSLPeerUnverifiedException pue) {
      System.out.println(ident+": Peer unverified");
    }
  }
}

在 J2SE 1.2 或 1.3 上运行服务器应用程序
如果您正在 J2SE 1.2 或 1.3 上运行 SimpleSSLServer 应用程序，则需要使用一个略微不同的（并且目前已过时的）JSSE API。不是导入，而是使用。该包还包含称为的类；但是，为了从获得证书对象数组，必须使用方法，而不是方法。

用红色突出显示的行是非常重要的两行：返回作为对象数组的证书链。这些证书对象建立对等方的（即客户机的）标识。数组中的第一个是客户机本身的证书；最后一个通常是 CA 证书。一旦我们拥有了对等方的证书，我们可以获取 DN 并将其显示到。是在包中定义的。

SimpleSSLClient 内幕
我们将研究的第一个客户机应用程序根本不能做什么。但是，在后面的示例中我们会扩展它来阐述更高级的功能。设置 SimpleSSLClient 的目的是为了方便地添加子类。打算覆盖下面四个方法：

目前，SimpleSSLClient 仅能理解和参数，这允许用户把客户机指向服务器。在这第一个基本示例中，返回（JVM 范围的）缺省工厂，如下所示：


protected SSLSocketFactory getSSLSocketFactory()
  throws IOException, GeneralSecurityException
{
  return (SSLSocketFactory)SSLSocketFactory.getDefault();
}

从子类的方法调用的方法，负责处理命令行参数，然后从子类获取来使用。然后它使用方法连接到服务器，并且使用方法在安全通道上开始传输数据。

方法相当简单。在使用连接到服务器之后，它调用安全套接字上的。这迫使 JSSE 完成 SSL 握手阶段，并因而触发服务器端上的。尽管 JSSE 确实会自动启动握手，但是仅当数据首次通过套接字发送时它才这样做。因为用户在键盘上输入消息之前我们不会发送任何数据，但是我们希望服务器立即报告连接，所以我们需要使用强制进行握手。

方法同样相当简单。它的首要任务把输入源包装到适当的，如下所示：

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

我们使用，因为它将帮我们把输入分割成单独的行。

接下来，方法把输出流 ― 在本案例中，由安全套接字提供 ― 包装到适当的中。服务器希望文本是以 UTF-8 编码的，因此我们可以让使用下列编码：

 
writer=new OutputStreamWriter(socket.getOutputStream(), "UTF-8");

主循环很简单；正如您在清单 3 中看到的，它看起来更象 SimpleSSLServer 中的主循环：

清单 3. SimpleSSLClient 主循环


boolean done=false;
while (!done) {
  String line=reader.readLine();
  if (line!=null) {
    writer.write(line);
    writer.write('\n');
    writer.flush();
  }
  else done=true;
}

基本的 JSSE 服务器和客户机代码就只有这些。现在，我们可以继续扩展 SimpleSSLClient，并且看看一些其它实现。

自制的 KeyStore
还记得我们是如何运行 SimpleSSLClient 的吗？命令如下：

 
java -Djavax.net.ssl.keyStore=clientKeys
   -Djavax.net.ssl.keyStorePassword=password 
   -Djavax.net.ssl.trustStore=clientTrust 
   -Djavax.net.ssl.trustStorePassword=password SimpleSSLClient

命令简直太长了！幸运的是，该示例及接下来的示例将为您演示如何设置一个带有到 KeyStore 和 TrustStore 的硬编码路径的。除了减少上述命令的长度之外，您将学习的技术将允许您设置多个对象，每个对象都带有不同的 KeyStore 和 TrustStore 设置。如果没有这种配置，JVM 中的每个安全连接必须使用相同的 KeyStore 和 TrustStore。尽管对于较小的应用程序而言这是可以接受的，但是较大的应用程序可能需要连接到多个代表许多不同用户的对等方。

介绍 CustomKeyStoreClient
对于第一个示例，我们将使用示例应用程序 CustomKeyStoreClient（可在本文的源代码中找到）来动态定义一个 KeyStore。在研究源代码之前，让我们看看正在使用的 CustomKeyStoreClient。对于这个练习，我们将指定 TrustStore 而不是 KeyStore。在 CustomKeyStoreClient 命令行上输入下列参数，我们将看到出现的结果：

 
java -Djavax.net.ssl.trustStore=clientTrust
   -Djavax.net.ssl.trustStorePassword=password CustomKeyStoreClient

假定客户机连接良好，服务器将报告说提供的证书是有效的。连接成功，因为已经硬编码了 KeyStore 的名称（）和密码（）。如果您为客户机 KeyStore 选择了另外的文件名或密码，那么可以使用新的命令行选项和来指定它们。

研究一下的源代码，做的第一件事是调用助手方法。稍后我们将考虑这是如何工作的；目前只是注明它返回对象数组，已经利用必需的 KeyStore 文件和密码对其进行了设置。

清单 4. CustomKeyStoreClient.getSSLSocketFactory


protected SSLSocketFactory getSSLSocketFactory()
  throws IOException, GeneralSecurityException
{
  // Call getKeyManagers to get suitable key managers
  KeyManager[] kms=getKeyManagers();

  // Now construct a SSLContext using these KeyManagers. We
  // specify a null TrustManager and SecureRandom, indicating that the
  // defaults should be used.
  SSLContext context=SSLContext.getInstance("SSL");
  context.init(kms, null, null);

  // Finally, we get a SocketFactory, and pass it to SimpleSSLClient.
  SSLSocketFactory ssf=context.getSocketFactory();
  return ssf;
}

获得数组之后，执行一些对所有 JSSE 定制通常都很重要的设置工作。为了构造，应用程序获取一个实例，对其进行初始化，然后使用生成一个。

当得到时，我们指定的协议；我们也可以在这放入特定的 SSL（或 TLS）协议版本，并且强制通信在特定的级别发生。通过指定，我们允许 JSSE 缺省至它能支持的最高级别。

的第一个参数是要使用的数组。第二个参数（这里保留为 null）类似于对象数组，稍后我们将使用它们。通过让第二个参数为 null，我们告诉 JSSE 使用缺省的 TrustStore，它从和系统属性挑选设置。第三个参数允许我们覆盖 JSSE 的随机数生成器（RNG）。RNG 是 SSL 的一个敏感领域，误用该参数会致使连接变得不安全。我们让该参数为 null，这样允许 JSSE 使用缺省的 ― 并且安全的！― 对象。

装入 KeyStore
接下来，我们将研究如何装入和初始化数组。先从清单 5 中的代码开始，然后我们将讨论正在发生什么。

清单 5. 装入和初始化 KeyManagers


protected KeyManager[] getKeyManagers()
  throws IOException, GeneralSecurityException
{
  // First, get the default KeyManagerFactory.
  String alg=KeyManagerFactory.getDefaultAlgorithm();
  KeyManagerFactory kmFact=KeyManagerFactory.getInstance(alg);
    
  // Next, set up the KeyStore to use. We need to load the file into
  // a KeyStore instance.
  FileInputStream fis=new FileInputStream(keyStore);
  KeyStore ks=KeyStore.getInstance("jks");
  ks.load(fis, keyStorePassword.toCharArray());
  fis.close();

  // Now we initialize the TrustManagerFactory with this KeyStore
  kmFact.init(ks, keyStorePassword.toCharArray());

  // And now get the TrustManagers
  KeyManager[] kms=kmFact.getKeyManagers();
  return kms;
}

首要工作是获取，但是要这样做，我们需要知道将使用哪种算法。幸运的是，JSSE 使缺省的算法可用。可以使用安全性属性配置缺省算法。

接下来，方法装入 KeyStore 文件。这其中包括从文件建立一个、获取一个实例，以及从装入。除了，需要知道流的格式（我们使用缺省的）和存储密码。存储密码必须作为字符数组提供。

CustomKeyStoreClient 包导入
为了访问类，我们必须导入和。其它类（如和）从 J2SE 1.4 起，是的成员。在 J2SE 1.2 或 1.3 中，这些类的位置不是标准的；例如，Sun JSSE 实现把它们放在中。

要说明的一个可能很有用的窍门是，会获取任何。您的应用程序可以从任何地方构建这些流；除了文件，您可以通过网络、从移动设备获取流，或者甚至直接生成流。

装入之后，我们使用它来初始化以前创建的。我们需要再次指定一个密码，这次是单独的证书密码。通常，对于 JSSE 而言，KeyStore 中的每个证书都需要具备与 KeyStore 本身相同的密码。自己构造可以克服这个限制。

初始化之后，它通常使用方法获取相应的对象的数组。

对于 CustomKeyStoreClient 而言，我们已经研究了如何从任意的位置（本文使用本地文件系统）装入 KeyStore，以及如何让证书和 KeyStore 本身使用不同的密码。稍后我们将研究如何允许 KeyStore 中的每个证书拥有不同的密码。尽管在本示例中我们着重于客户机端，但是，我们可以在服务器端使用相同的技术来构建适当的对象。

CustomTrustStoreClient 包导入
同样，本示例中使用的类会出现在不同 JSSE 供应商的不同包中。在 J2SE 1.4 中，位于中；在 J2SE 1.2 或 1.3 中，通常它位于中。

使用您自己的 TrustStore
覆盖 JSSE 的缺省 TrustStore 非常类似于我们刚才用 KeyStore 所做的工作，这并不令人惊奇。我们已经设置了 CustomTrustStoreClient（可在本文的源代码中找到）来使用硬编码的 KeyStore 和硬编码的 TrustStore。开始运行它所需做的全部工作就是输入命令：。

CustomTrustStoreClient 希望 KeyStore 将是一个名为并且密码为的文件。希望 TrustStore 将是一个名为，密码为的文件。就象使用 CustomKeyStoreClient 一样，可以使用、、和参数覆盖这些缺省值。

在许多方面与 CustomKeyStoreClient 中相同方法是一样的。我们甚至从 CustomKeyStoreClient 调用方法来获取与前面示例中相同的定制的对象数组。但是这时还必须获取一个定制的对象数组。在清单 6 中，我们可以看到如何使用助手方法获取定制的对象：

清单 6. getSSLSocketFactory 如何使用 TrustManagers


protected SSLSocketFactory getSSLSocketFactory()
  throws IOException, GeneralSecurityException
{
  // Call getTrustManagers to get suitable trust managers
  TrustManager[] tms=getTrustManagers();
    
  // Call getKeyManagers (from CustomKeyStoreClient) to get suitable
  // key managers
  KeyManager[] kms=getKeyManagers();

  // Next construct and initialize a SSLContext with the KeyStore and
  // the TrustStore. We use the default SecureRandom.
  SSLContext context=SSLContext.getInstance("SSL");
  context.init(kms, tms, null);

  // Finally, we get a SocketFactory, and pass it to SimpleSSLClient.
  SSLSocketFactory ssf=context.getSocketFactory();
  return ssf;
}

这时，当初始化上下文时，我们覆盖了 KeyStore 和 TrustStore。但是，我们仍然让 JSSE 通过传递作为第三个参数来使用它缺省的。

也非常类似于 CustomKeyStoreClient 的等价物同样不足为奇，如清单 7 所示：

清单 7. 装入和初始化 TrustManagers


protected TrustManager[] getTrustManagers()
  throws IOException, GeneralSecurityException
{
  // First, get the default TrustManagerFactory.
  String alg=TrustManagerFactory.getDefaultAlgorithm();
  TrustManagerFactory tmFact=TrustManagerFactory.getInstance(alg);
    
  // Next, set up the TrustStore to use. We need to load the file into
  // a KeyStore instance.
  FileInputStream fis=new FileInputStream(trustStore);
  KeyStore ks=KeyStore.getInstance("jks");
  ks.load(fis, trustStorePassword.toCharArray());
  fis.close();

  // Now we initialize the TrustManagerFactory with this KeyStore
  tmFact.init(ks);

  // And now get the TrustManagers
  TrustManager[] tms=tmFact.getTrustManagers();
  return tms;
}

就象以前一样，方法首先根据缺省算法实例化一个。然后将 TrustStore 文件装入对象 ― 是的，命名不大恰当 ― 并且初始化。

跟 KeyStore 等价物不同，请注意，当初始化时，无需提供密码。不象私钥，可信的证书无需利用单独的密码进行保护。

到目前为止，我们已经研究了如何动态地覆盖 KeyStore 和 TrustStore。到这两个示例都完成时，您应该非常清楚如何设置和，并使用这些来“播种”一个。最后的示例有点烦琐：我们将构建自己的实现。

定制 KeyManager 设置：选择别名
当运行客户机应用程序的以前版本时，您是否注意到了服务器显示的是哪个证书 DN？我们故意设置客户机 KeyStore 以获得两个可接受的证书，一个用于 Alice，另一个用于 Bob。在这个案例中，JSSE 将选择任何一个它认为合适的证书。在我的安装中，似乎始终选取 Bob 的证书，但是您的 JSSE 的行为可能有所不同。

我们的示例应用程序 ― SelectAliasClient 允许您选择提供哪个证书。因为我们在 Keystore 中按照别名或命名了每个证书，所以要选择 Alice 的证书可输入命令：。

当客户机连接并且 SSL 握手完成时，服务器将用如下所示进行响应：


1: New connection request
1: Request from CN=Alice, OU=developerWorks, O=IBM, L=Winchester, 
      ST=Hampshire, C=UK

（或者创建 Alice 的证书时所选的任何值）。类似地，如果选择 Bob 的证书，请输入：，服务器将报告下述信息：


2: New connection request
2: Request from CN=Bob, OU=developerWorks, O=IBM, L=Winchester, 
      ST=Hampshire, C=UK

定制 KeyManager 实现
为了强制选择一个特殊的别名，我们将编写一个实现，通常由 JSSE 使用来进行 SSL 通信。我们的实现将包含一个真正的，并且简单地通过它传递大多数的调用。它拦截的唯一方法是；我们的实现检查以便了解所需的别名有效还是无效，如果有效，则返回它。

在 SSL 握手阶段，接口使用许多方法来检索密钥，然后使用它来标识对等方。在参考资料部分可以找到所有方法的参考。下列方法对于本练习很重要：

定制 KeyManager 中的控制流
控制流的工作如下所示：

JSSE 调用以发现要使用的别名。
在真实的上调用来发现一个有效的别名列表，以便于它能检查所需的别名是否有效。
JSSE 通过指定正确的别名调用的和，X509KeyManager 让调用可以访问被包装的 KeyManager。

KeyManager 的方法实际上需要多次调用，一次对应一个 JSSE 安装支持的密钥类型，如清单 8 所示：

清单 8. 强制别名的选择


public String chooseClientAlias(String[] keyType, Principal[] issuers,
                                Socket socket)
{
  // For each keyType, call getClientAliases on the base KeyManager
  // to find valid aliases. If our requested alias is found, select it
  // for return.
  boolean aliasFound=false;

  for (int i=0; i<keyType.length && !aliasFound; i++) {
    String[] validAliases=baseKM.getClientAliases(keyType[i], issuers);
    if (validAliases!=null) {
      for (int j=0; j<validAliases.length && !aliasFound; j++) {
        if (validAliases[j].equals(alias)) aliasFound=true;
      }
    }
  }

  if (aliasFound) return alias;
  else return null;
}

需要的其它五种方法的实现；这些只是调用它们在上的对应部分。

目前，它仍然使用，而不是通常的。这发生在中，它首先从其它示例中调用和，但是接着将每个从返回的封装进一个实例，如清单 9 所示：

清单 9. 封装 X509KeyManagers


protected SSLSocketFactory getSSLSocketFactory() 
  throws IOException, GeneralSecurityException
{
  // Call the superclasses to get suitable trust and key managers
  KeyManager[] kms=getKeyManagers();
  TrustManager[] tms=getTrustManagers();

  // If the alias has been specified, wrap recognized KeyManagers
  // in AliasForcingKeyManager instances.
  if (alias!=null) {
    for (int i=0; i<kms.length; i++) {
      // We can only deal with instances of X509KeyManager
      if (kms[i] instanceof X509KeyManager)
        kms[i]=new AliasForcingKeyManager((X509KeyManager)kms[i], alias);
    }
  }

  // Now construct a SSLContext using these (possibly wrapped)
  // KeyManagers, and the TrustManagers. We still use a null
  // SecureRandom, indicating that the defaults should be used.
  SSLContext context=SSLContext.getInstance("SSL");
  context.init(kms, tms, null);

  // Finally, we get a SocketFactory, and pass it to SimpleSSLClient.
  SSLSocketFactory ssf=context.getSocketFactory();
  return ssf;
}

KeyManager 重新打包
J2SE 1.2 和 1.3 中的和在 J2SE 1.4 中都从供应商特定的包中移到了中；当接口移动时，方法说明会略微发生一点变化。

可以使用本文探讨的技术覆盖的任何方面。类似地，可以使用它们代替，更改 JSSE 的机制以决定是否信任从远程对等方流出的证书。

结束语
本文已经讨论了相当多的技巧和技术，因此让我们以快速回顾来结束本文。现在您应当基本了解如何：

在适当的地方，我还建议扩展这些技术以用于各种应用程序案例。在您自己的实现中封装的技巧可用于 JSSE 中的许多其它类，当然，利用和可以做更有趣的事情，而不只是装入硬编码的文件。

不管您如何选择实现本文演示的高级 JSSE 定制，任何一个都不是随便就可以实现的。在调整 SSL 内部机理的时候，请牢记：一个错误就会致使您连接变得不安全，这很重要。