用OpenSSL与JAVA(JSSE)通信

用OpenSSL与JAVA(JSSE)通信

概念
JAVA使用keystore文件来存储所有KEY，keystore文件可以存放多个KEY，访问它需要密码。
下面我介绍下如何将用OpenSSL做自签名的证书一文中介绍的OpenSSL产生的KEY与JAVA的KEY转换后使用，从而达到JAVA与OpenSSL通信的目的。


用OpenSSL生成CA根证书，即(P1,V1)
此步骤参见用OpenSSL做自签名的证书一文


在JAVA环境下生成自己的KEY，即(P2,V2)

keytool -genkey -alias clientapp -keystore mycerts

注意：这里会提示输入访问keystore的密码，以及组织、城市、省份，一定要与CA根证书的一致，否则不能被CA签名。


从keystore中导出public key，即P2

keytool -keystore mycerts -certreq -alias clientapp -file clientapp.crs


用CA根证书为这个public key进行签名，即用V1给P2加密

openssl ca -out clientapp.pem -config ./openssl.cnf -infiles clientapp.crs
 

转换PEM到DER格式

openssl x509 -in clientapp.pem -out clientapp.der -outform DER


导入CA证书，即P1

keytool -keystore mycerts -alias systemca -import -file cacert.pem


导入用户证书，即被V1加密过的P2

keytool -keystore mycerts -alias clientapp -import -file clientapp.der

注意：这里一定要先导入CA证书再导入用户证书，否则会报错。

现在我们就生成了JAVA服务器使用的所有KEY了，在程序中将mycerts这个keystore导入就可以了。
如果客户端是使用OpenSSL的程序，那么用CA证书cacert.pem就能正常通信了，如果也是JAVA程序，那么我们需要将CA证书也转换成keystore：

keytool -import -keystore clikeystore -import -trustcacerts -file cacert.pem

生成的clikeystore供JAVA客户端使用，就能通信。


再附上SVR和CLI的JAVA程序，我已经用上面的KEY都测试通过：
SVR端：

1.  import  java.io. * ;
2.  import  java.net. * ;
3.  import  com.sun.net.ssl.KeyManagerFactory;
4.  import  com.sun.net.ssl.KeyManager;
5.  import  com.sun.net.ssl.TrustManagerFactory;
6.  import  com.sun.net.ssl.TrustManager;
7.  import  com.sun.net.ssl.SSLContext;
8.  import  javax.net.ServerSocketFactory;
9.  import  java.security.KeyStore;
10. 
    
11.  public   class  svr  implements  Runnable  {
12.   
13.    public   static   final   int  PORT  =   5555 ;
14.    public   static   final  String HOST  =   " localhost " ;
15.    public   static   final  String QUESTION  =   " Knock, knock. " ;
16.    public   static   final  String ANSWER  =   " Who's there? " ;
17. 
    
18.    //  The new constants that are used during setup. 
19.     public   static   final  String KEYSTORE_FILE  =   " mycerts " ; // "server_keystore"; 
20.     public   static   final  String ALGORITHM  =   " sunx509 " ;
21.    public   static   final  String PASSWORD  =   " churchillobjects " ;
22.   
23.    public   static   void  main(String[] args)  {
24.      new  Thread( new  svr()).start();
25.   } 
26.   
27.    public   void  run()  {
28.     ServerSocket ss  =   null ;
29.      try    {
30. 
    
31.        //  Local references used for clarity. Their presence
32.        //  here is part of the reason we need to import
33.        //  so many classes. 
34.        KeyManagerFactory kmf;
35.       KeyManager[] km;
36.       KeyStore ks;
37.       TrustManagerFactory tmf;
38.       TrustManager[] tm;
39.       SSLContext sslc;
40.       
41.        //  Create a keystore that will read the JKS (Java KeyStore)
42.        //  file format which was created by the keytool utility. 
43.        ks  =  KeyStore.getInstance( " JKS " );
44.       
45.        //  Load the keystore object with the binary keystore file and
46.        //  a byte array representing its password. 
47.        ks.load( new  FileInputStream(KEYSTORE_FILE), PASSWORD.toCharArray());
48.       
49.        //  Gives us a factory for key managers that will let
50.        //  us handle the asymetric keys we created earlier. 
51.        kmf  =  KeyManagerFactory.getInstance(ALGORITHM);
52. 
    
53.        //  Initialize the key manager factory with the keystore object,
54.        //  again using the same password for security since it is going to
55.        //  access the private key. 
56.        kmf.init(ks, PASSWORD.toCharArray());
57.       
58.        //  Now we can get the key managers from the factory, since it knows
59.        //  what type we are using now. 
60.        km  =  kmf.getKeyManagers();
61.       
62.        //  Next, create a trust manager factory using the same algorithm.
63.        //  This is to avoid using the certificates in cacerts that
64.        //  represent an authentication security risk. 
65.        tmf  =  TrustManagerFactory.getInstance(ALGORITHM);
66.       
67.        //  then initialize it with the keystore object. This time we don't
68.        //  need the keystore password. This is because trusted certificates
69.        //  are not a sensitive element in the keystore, unlike the
70.        //  private keys. 
71.        tmf.init(ks);
72.       
73.        //  Once that's initialized, get the trust managers from the factory. 
74.        tm  =  tmf.getTrustManagers();
75.       
76.        //  Almost done, we need a context object that will get our
77.        //  server socket factory. We specify TLS to indicate that we will
78.        //  need a server socket factory that supports SSL. 
79.        sslc  =  SSLContext.getInstance( " TLS " );
80.       
81.        //  Initialize the context object with the key managers and trust
82.        //  managers we got earlier. The third parameter is an optional
83.        //  SecureRandom object. By passing in null, we are letting the
84.        //  context object create its own. 
85.        sslc.init(km, tm,  null );
86.       
87.        //  Finally, we get the ordinary-looking server socket factory
88.        //  from the context object. 
89.        ServerSocketFactory ssf  =  sslc.getServerSocketFactory();
90.       
91.        //  From the factory, we simply ask for an ordinary-looking
92.        //  server socket on the port we wish. 
93.        ss  =  ssf.createServerSocket(PORT);
94. 
    
95.       listen(ss);
96.     } 
97.       catch (Exception e)  {
98.       e.printStackTrace();
99.     } 
100.       finally  {
101.        if (ss != null )  {
102.          try  {
103.           ss.close();
104.         } 
105.           catch (IOException e)  {
106.            //  oh, well 
107.          } 
108.       } 
109.       System.exit( 0 );
110.     } 
111.   } 
112.   
113.    static   void  listen(ServerSocket ss)  throws  Exception  {
114.     System.out.println( " Ready for connections. " );
115.      while ( true )  {
116.       Socket s  =  ss.accept();
117.       BufferedWriter bw  =   new  BufferedWriter(
118.          new  OutputStreamWriter(s.getOutputStream()));
119.       BufferedReader br  =   new  BufferedReader(
120.          new  InputStreamReader(s.getInputStream()));
121.       String q  =  br.readLine();
122.        if ( ! QUESTION.equals(q))  {
123.          throw   new  RuntimeException( " Wrong question: / ""  + q +  " / "" );
124.       } 
125.       System.out.println( " Question: / ""  + q +  " / "" );
126.       bw.write(ANSWER + " /n " );
127.       bw.flush();
128.       s.close();
129.     } 
130.   } 
131. } 

CLI端程序：

1.  import  java.io. * ;
2.  import  java.net. * ;
3.  import  com.sun.net.ssl.KeyManagerFactory;
4.  import  com.sun.net.ssl.TrustManagerFactory;
5.  import  com.sun.net.ssl.SSLContext;
6.  import  java.security.KeyStore;
7.  import  javax.net.SocketFactory;
9.  public   class  cli  implements  Runnable  {
10.   
11.    public   static   final   int  PORT  =   5555 ;
12.    public   static   final  String HOST  =   " localhost " ;
13.    public   static   final  String KEYSTORE_FILE  =   " clikeystore " ; // "client_keystore"; 
14.     public   static   final  String ALGORITHM  =   " sunx509 " ;
15.    public   static   final  String PASSWORD  =   " churchillobjects " ;
16.    public   static   final  String QUESTION  =   " Knock, knock. " ;
17.    public   static   final  String ANSWER  =   " Who's there? " ;
18.   
19.    public   static   void  main(String[] args)  {
20.      new  Thread( new  cli()).start();
21.   } 
22.   
23.    public   void  run()  {
24.     Socket socket  =   null ;
25.      try  {
26.       KeyManagerFactory kmf;
27.       KeyStore ks;
28.       TrustManagerFactory tmf;
29.       SSLContext sslc;
31.       kmf  =  KeyManagerFactory.getInstance(ALGORITHM);
32.       ks  =  KeyStore.getInstance(  " JKS "  );
33.       ks.load( new  FileInputStream(KEYSTORE_FILE), PASSWORD.toCharArray());
34.       kmf.init(ks, PASSWORD.toCharArray());
35.       tmf  =  TrustManagerFactory.getInstance(ALGORITHM);
36.       tmf.init(ks);
37.       sslc  =  SSLContext.getInstance( " TLS " );
38.       sslc.init(kmf.getKeyManagers(), tmf.getTrustManagers(),  null );
40.        //  The process is different from here on the client. Instead of
41.        //  getting a ServerSocketFactory, we ask for a SocketFactory from
42.        //  the SSL context. 
43.        SocketFactory sf  =  sslc.getSocketFactory();
45.        //  Then we get the socket from the factory and treat it
46.        //  as if it were a standard (plain) socket. 
47.        socket  =  sf.createSocket(HOST, PORT);
48.     
49.       doQuery(socket);
50.     } 
51.       catch (Exception e)  {
52.       e.printStackTrace();
53.     } 
54.       finally  {
55.        if (socket != null )  {
56.          try  {
57.           socket.close();
58.         } 
59.           catch (IOException e)  {
60.            //  oh, well 
61.          } 
62.       } 
63.       System.exit( 0 );
64.     } 
65.   } 
66.  
67.     private   void  doQuery(Socket s)  throws  Exception  {
68.     BufferedWriter bw  =   new  BufferedWriter( new  OutputStreamWriter(s.getOutputStream()));
69.     BufferedReader br  =   new  BufferedReader( new  InputStreamReader(s.getInputStream()));
70.     bw.write(QUESTION + " /n " );
71.     bw.flush();
72.     String response  =  br.readLine();
73.      if ( ! ANSWER.equals(response))  {
74.        throw   new  RuntimeException( " Wrong answer: / ""  + response +  " / "" );
75.     } 
76.     System.out.println( " Got the right answer: / ""  + response +  " / "" );
77.   } 
78. } 

以上方法主要参考了如下两个网页：

http://www.churchillobjects.com/c/11201g.html

http://mark.foster.cc/kb/openssl-keytool.html

原文：http://www.blogjava.net/alwayscy/archive/2008/11/22/85161.html