java 下 ssl 通信原理及实例-亚博电竞手机版

有关ssl的原理和介绍在网上已经有不少，对于java下使用keytool生成证书，配置ssl通信的教程也非常多。但如果我们不能够亲自动手做一个ssl sever和ssl client，可能就永远也不能深入地理解java环境下，ssl的通信是如何实现的。对ssl中的各种概念的认识也可能会仅限于可以使用的程度。本文通过构造一个简单的ssl server和ssl client来讲解java环境下ssl的通信原理。

首先我们先回顾一下常规的java socket编程。在java下写一个socket服务器和客户端的例子还是比较简单的。

服务端很简单：侦听8080端口，并把客户端发来的字符串返回去。以下是服务端的代码：

package org.bluedash.tryssl;  import java.io.bufferedreader; import java.io.ioexception; import java.io.inputstreamreader; import java.io.printwriter; import java.net.serversocket; import java.net.socket; public class server extends thread {     private socket socket;     public server(socket socket) {         this.socket = socket;     }     public void run() {         try {             bufferedreader reader = new bufferedreader(new inputstreamreader(socket.getinputstream()));             printwriter writer = new printwriter(socket.getoutputstream());             string data = reader.readline();             writer.println(data);             writer.close();             socket.close();         } catch (ioexception e) {          }     }     public static void main(string[] args) throws exception {         while (true) {             new server((new serversocket(8080)).accept()).start();         }     } }

客户端也非常简单：向服务端发起请求，发送一个”hello”字串，然后获得服务端的返回。下面是客户端的代码：

package org.bluedash.tryssl;  import java.io.bufferedreader; import java.io.inputstreamreader; import java.io.printwriter; import java.net.socket; public class client {     public static void main(string[] args) throws exception {         socket s = new socket("localhost", 8080);         printwriter writer = new printwriter(s.getoutputstream());         bufferedreader reader = new bufferedreader(new inputstreamreader(s.getinputstream()));         writer.println("hello");         writer.flush();         system.out.println(reader.readline());         s.close();     } }

把服务端运行起来后，执行客户端，我们将得到”hello”的返回。

就是这样一套简单的网络通信的代码，我们来把它改造成使用ssl通信。在ssl通信协议中，我们都知道首先服务端必须有一个数字证书，当客户端连接到服务端时，会得到这个证书，然后客户端会判断这个证书是否是可信的，如果是，则交换信道加密密钥，进行通信。如果不信任这个证书，则连接失败。

因此，我们首先要为服务端生成一个数字证书。java环境下，数字证书是用keytool生成的，这些证书被存储在store的概念中，就是证书仓库。我们来调用keytool命令为服务端生成数字证书和保存它使用的证书仓库：

keytool -genkey -v -alias bluedash-ssl-demo-server -keyalg rsa -keystore ./server_ks -dname "cn=localhost,ou=cn,o=cn,l=cn,st=cn,c=cn" -storepass server -keypass 123123

这样，我们就将服务端证书bluedash-ssl-demo-server保存在了server_ksy这个store文件当中。有关keytool的用法在本文中就不再多赘述。执行上面的命令得到如下结果：

generating 1,024 bit rsa key pair and self-signed certificate (sha1withrsa) with a validity of 90 days         for: cn=localhost, ou=cn, o=cn, l=cn, st=cn, c=cn [storing ./server_ks]

然后，改造亚博电竞手机版的服务端代码，让服务端使用这个证书，并提供ssl通信：

package org.bluedash.tryssl;  import java.io.bufferedreader; import java.io.fileinputstream; import java.io.ioexception; import java.io.inputstreamreader; import java.io.printwriter; import java.net.serversocket; import java.net.socket; import java.security.keystore;  import javax.net.serversocketfactory; import javax.net.ssl.keymanagerfactory; import javax.net.ssl.sslcontext; import javax.net.ssl.sslserversocket;  public class sslserver extends thread {     private socket socket;      public sslserver(socket socket) {         this.socket = socket;     }      public void run() {         try {             bufferedreader reader = new bufferedreader(new inputstreamreader(socket.getinputstream()));             printwriter writer = new printwriter(socket.getoutputstream());              string data = reader.readline();             writer.println(data);             writer.close();             socket.close();         } catch (ioexception e) {          }     }      private static string server_key_store = "/users/liweinan/projs/ssl/src/main/resources/meta-inf/server_ks";     private static string server_key_store_password = "123123";      public static void main(string[] args) throws exception {         system.setproperty("javax.net.ssl.truststore", server_key_store);         sslcontext context = sslcontext.getinstance("tls");          keystore ks = keystore.getinstance("jceks");         ks.load(new fileinputstream(server_key_store), null);         keymanagerfactory kf = keymanagerfactory.getinstance("sunx509");         kf.init(ks, server_key_store_password.tochararray());         context.init(kf.getkeymanagers(), null, null);         serversocketfactory factory = context.getserversocketfactory();         serversocket _socket = factory.createserversocket(8443);         ((sslserversocket) _socket).setneedclientauth(false);          while (true) {             new sslserver(_socket.accept()).start();         }     } }

可以看到，服务端的socket准备设置工作大大增加了，增加的代码的作用主要是将证书导入并进行使用。此外，所使用的socket变成了sslserversocket，另外端口改到了8443（这个不是强制的，仅仅是为了遵守习惯）。另外，最重要的一点，服务端证书里面的cn一定和服务端的域名统一，我们的证书服务的域名是localhost，那么我们的客户端在连接服务端时一定也要用localhost来连接，否则根据ssl协议标准，域名与证书的cn不匹配，说明这个证书是不安全的，通信将无法正常运行。

有了服务端，我们原来的客户端就不能使用了，必须要走ssl协议。由于服务端的证书是我们自己生成的，没有任何受信任机构的签名，所以客户端是无法验证服务端证书的有效性的，通信必然会失败。所以我们需要为客户端创建一个保存所有信任证书的仓库，然后把服务端证书导进这个仓库。这样，当客户端连接服务端时，会发现服务端的证书在自己的信任列表中，就可以正常通信了。

因此现在我们要做的是生成一个客户端的证书仓库，因为keytool不能仅生成一个空白仓库，所以和服务端一样，我们还是生成一个证书加一个仓库（客户端证书加仓库）：

keytool -genkey -v -alias bluedash-ssl-demo-client -keyalg rsa -keystore ./client_ks -dname "cn=localhost,ou=cn,o=cn,l=cn,st=cn,c=cn" -storepass client -keypass 456456

结果如下：

generating 1,024 bit rsa key pair and self-signed certificate (sha1withrsa) with a validity of 90 days         for: cn=localhost, ou=cn, o=cn, l=cn, st=cn, c=cn [storing ./client_ks]

接下来，我们要把服务端的证书导出来，并导入到客户端的仓库。第一步是导出服务端的证书：

keytool -export -alias bluedash-ssl-demo-server -keystore ./server_ks -file server_key.cer

执行结果如下：

enter keystore password:  server certificate stored in file 

然后是把导出的证书导入到客户端证书仓库：

keytool -import -trustcacerts -alias bluedash-ssl-demo-server -file ./server_key.cer -keystore ./client_ks

结果如下：

enter keystore password:  client owner: cn=localhost, ou=cn, o=cn, l=cn, st=cn, c=cn issuer: cn=localhost, ou=cn, o=cn, l=cn, st=cn, c=cn serial number: 4c57c7de valid from: tue aug 03 15:40:14 cst 2010 until: mon nov 01 15:40:14 cst 2010 certificate fingerprints:          md5:  fc:d4:8b:36:3f:1b:30:ea:6d:63:55:4f:c7:68:3b:0c          sha1: e1:54:2f:7c:1a:50:f5:74:aa:63:1e:f9:cc:b1:1c:73:aa:34:8a:c4          signature algorithm name: sha1withrsa          version: 3 trust this certificate? [no]:  yes certificate was added to keystore

好，准备工作做完了，我们来撰写客户端的代码：

package org.bluedash.tryssl;  import java.io.bufferedreader; import java.io.inputstreamreader; import java.io.printwriter; import java.net.socket;  import javax.net.socketfactory; import javax.net.ssl.sslsocketfactory;  public class sslclient {      private static string client_key_store = "/users/liweinan/projs/ssl/src/main/resources/meta-inf/client_ks";      public static void main(string[] args) throws exception {         // set the key store to use for validating the server cert.         system.setproperty("javax.net.ssl.truststore", client_key_store);          system.setproperty("javax.net.debug", "ssl,handshake");          sslclient client = new sslclient();         socket s = client.clientwithoutcert();          printwriter writer = new printwriter(s.getoutputstream());         bufferedreader reader = new bufferedreader(new inputstreamreader(s                 .getinputstream()));         writer.println("hello");         writer.flush();         system.out.println(reader.readline());         s.close();     }      private socket clientwithoutcert() throws exception {         socketfactory sf = sslsocketfactory.getdefault();         socket s = sf.createsocket("localhost", 8443);         return s;     } }

可以看到，除了把一些类变成ssl通信类以外，客户端也多出了使用信任证书仓库的代码。以上，我们便完成了ssl单向握手通信。即：客户端验证服务端的证书，服务端不认证客户端的证书。

以上便是java环境下ssl单向握手的全过程。因为我们在客户端设置了日志输出级别为debug：

system.setproperty("javax.net.debug", "ssl,handshake");

因此我们可以看到ssl通信的全过程，这些日志可以帮助我们更具体地了解通过ssl协议建立网络连接时的全过程。

结合日志，我们来看一下ssl双向认证的全过程：



第一步: 客户端发送clienthello消息，发起ssl连接请求，告诉服务器自己支持的ssl选项（加密方式等）。

*** clienthello, tlsv1

第二步: 服务器响应请求，回复serverhello消息，和客户端确认ssl加密方式：

*** serverhello, tlsv1

第三步: 服务端向客户端发布自己的公钥。

第四步: 客户端与服务端的协通沟通完毕，服务端发送serverhellodone消息：

*** serverhellodone

第五步: 客户端使用服务端给予的公钥，创建会话用密钥（ssl证书认证完成后，为了提高性能，所有的信息交互就可能会使用对称加密算法），并通过clientkeyexchange消息发给服务器：

*** clientkeyexchange, rsa premastersecret, tlsv1

第六步： 客户端通知服务器改变加密算法，通过changecipherspec消息发给服务端：

main, write: tlsv1 change cipher spec, length = 1

第七步： 客户端发送finished消息，告知服务器请检查加密算法的变更请求：

*** finished

第八步：服务端确认算法变更，返回changecipherspec消息

main, read: tlsv1 change cipher spec, length = 1

第九步：服务端发送finished消息，加密算法生效：

*** finished

那么如何让服务端也认证客户端的身份，即双向握手呢？其实很简单，在服务端代码中，把这一行：

((sslserversocket) _socket).setneedclientauth(false);

改成：

((sslserversocket) _socket).setneedclientauth(true);

就可以了。但是，同样的道理，现在服务端并没有信任客户端的证书，因为客户端的证书也是自己生成的。所以，对于服务端，需要做同样的工作：把客户端的证书导出来，并导入到服务端的证书仓库：

keytool -export -alias bluedash-ssl-demo-client -keystore ./client_ks -file client_key.cer enter keystore password:  client certificate stored in file   keytool -import -trustcacerts -alias bluedash-ssl-demo-client -file ./client_key.cer -keystore ./server_ks enter keystore password:  server owner: cn=localhost, ou=cn, o=cn, l=cn, st=cn, c=cn issuer: cn=localhost, ou=cn, o=cn, l=cn, st=cn, c=cn serial number: 4c57c80b valid from: tue aug 03 15:40:59 cst 2010 until: mon nov 01 15:40:59 cst 2010 certificate fingerprints:          md5:  db:91:f4:1e:65:d1:81:f2:1e:a6:a3:55:3f:e8:12:79          sha1: bf:77:56:61:04:dd:95:fc:e5:84:48:5c:be:60:af:02:96:a2:e1:e2          signature algorithm name: sha1withrsa          version: 3 trust this certificate? [no]:  yes certificate was added to keystore

完成了证书的导入，还要在客户端需要加入一段代码，用于在连接时，客户端向服务端出示自己的证书：

package org.bluedash.tryssl;  import java.io.bufferedreader; import java.io.fileinputstream; import java.io.inputstreamreader; import java.io.printwriter; import java.net.socket; import java.security.keystore; import javax.net.socketfactory; import javax.net.ssl.keymanagerfactory; import javax.net.ssl.sslcontext; import javax.net.ssl.sslsocketfactory;  public class sslclient {     private static string client_key_store = "/users/liweinan/projs/ssl/src/main/resources/meta-inf/client_ks";     private static string client_key_store_password = "456456";      public static void main(string[] args) throws exception {         // set the key store to use for validating the server cert.         system.setproperty("javax.net.ssl.truststore", client_key_store);         system.setproperty("javax.net.debug", "ssl,handshake");         sslclient client = new sslclient();         socket s = client.clientwithcert();          printwriter writer = new printwriter(s.getoutputstream());         bufferedreader reader = new bufferedreader(new inputstreamreader(s.getinputstream()));         writer.println("hello");         writer.flush();         system.out.println(reader.readline());         s.close();     }      private socket clientwithoutcert() throws exception {         socketfactory sf = sslsocketfactory.getdefault();         socket s = sf.createsocket("localhost", 8443);         return s;     }      private socket clientwithcert() throws exception {         sslcontext context = sslcontext.getinstance("tls");         keystore ks = keystore.getinstance("jceks");          ks.load(new fileinputstream(client_key_store), null);         keymanagerfactory kf = keymanagerfactory.getinstance("sunx509");         kf.init(ks, client_key_store_password.tochararray());         context.init(kf.getkeymanagers(), null, null);          socketfactory factory = context.getsocketfactory();         socket s = factory.createsocket("localhost", 8443);         return s;     } }

通过比对单向认证的日志输出，我们可以发现双向认证时，多出了服务端认证客户端证书的步骤：

*** certificaterequest cert types: rsa, dss cert authorities:   *** serverhellodone  *** certificateverify main, write: tlsv1 handshake, length = 134 main, write: tlsv1 change cipher spec, length = 1

在 @*** serverhellodone@ 之前，服务端向客户端发起了需要证书的请求 @*** certificaterequest@ 。

在客户端向服务端发出 @change cipher spec@ 请求之前，多了一步客户端证书认证的过程 @*** certificateverify@ 。

客户端与服务端互相认证证书的情景，可参考下图：

参考资料

1. change cipher spec protocol

2. ssl & tls essentials: securing the web