Java加密技术（九）——初探SSL

最新推荐文章于 2021-10-17 15:52:08 发布

yangcbyang

最新推荐文章于 2021-10-17 15:52:08 发布

阅读量462

点赞数

分类专栏： Java／Security

Java／Security 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

在 Java加密技术（八）中，我们模拟了一个基于RSA非对称加密网络的安全通信。现在我们深度了解一下现有的安全网络通信——SSL。
我们需要构建一个由CA机构签发的有效证书，这里我们使用上文中生成的自签名证书 zlex.cer
这里，我们将证书导入到我们的密钥库。

     Shell代码   
     
 keytool -import -alias www.zlex.org -file d:/zlex.cer -keystore d:/zlex.keystore

其中
-import表示导入
-alias指定别名，这里是 www.zlex.org
-file指定算法，这里是 d:/zlex.cer
-keystore指定存储位置，这里是 d:/zlex.keystore
在这里我使用的密码为 654321

控制台输出：

     Console代码   
     
   
 输入keystore密码：  
 再次输入新密码:  
 所有者:CN=www.zlex.org, OU=zlex, O=zlex, L=BJ, ST=BJ, C=CN  
 签发人:CN=www.zlex.org, OU=zlex, O=zlex, L=BJ, ST=BJ, C=CN  
 序列号:4a1e48df  
 有效期: Thu May 28 16:18:39 CST 2009 至Wed Aug 26 16:18:39 CST 2009  
 证书指纹:  
          MD5:19:CA:E6:36:E2:DF:AD:96:31:97:2F:A9:AD:FC:37:6A  
          SHA1:49:88:30:59:29:45:F1:69:CA:97:A9:6D:8A:CF:08:D2:C3:D5:C0:C4  
          签名算法名称:SHA1withRSA  
          版本: 3  
 信任这个认证？ [否]：  y  
 认证已添加至keystore中  

OK，最复杂的准备工作已经完成。
接下来我们将域名 www.zlex.org定位到本机上。打开 C:\Windows\System32\drivers\etc\hosts文件，将 www.zlex.org绑定在本机上。在文件末尾追加 127.0.0.1 www.zlex.org。现在通过地址栏访问 http://www.zlex.org，或者通过 ping命令，如果能够定位到本机，域名映射就搞定了。
现在，配置tomcat。先将 zlex.keystore拷贝到tomcat的conf目录下，然后配置 server.xml。将如下内容加入配置文件

     Xml代码   
     
   
 <Connector  
     SSLEnabled="true"  
     URIEncoding="UTF-8"  
     clientAuth="false"  
     keystoreFile="conf/zlex.keystore"  
     keystorePass="123456"  
     maxThreads="150"  
     port="443"  
     protocol="HTTP/1.1"  
     scheme="https"  
     secure="true"  
     sslProtocol="TLS" />  

注意 clientAuth="false"测试阶段，置为 false，正式使用时建议使用 true。现在启动tomcat，访问 https://www.zlex.org/。

显然，证书未能通过认证，这个时候你可以选择安装证书（上文中的 zlex.cer文件就是证书），作为 受信任的根证书颁发机构导入，再次重启浏览器（IE，其他浏览器对于域名www.zlex.org不支持本地方式访问），访问 https://www.zlex.org/，你会看到地址栏中会有个小锁

，就说明安装成功。所有的浏览器联网操作已经在RSA加密解密系统的保护之下了。但似乎我们感受不到。
这个时候很多人开始怀疑，如果我们要手工做一个这样的https的访问是不是需要把浏览器的这些个功能都实现呢？不需要！

接着上篇内容，给出如下代码实现：

     Java代码   
     
   
 import java.io.FileInputStream;  
 import java.security.KeyStore;  
 import java.security.PrivateKey;  
 import java.security.PublicKey;  
 import java.security.Signature;  
 import java.security.cert.Certificate;  
 import java.security.cert.CertificateFactory;  
 import java.security.cert.X509Certificate;  
 import java.util.Date;  
   
 import javax.crypto.Cipher;  
 import javax.net.ssl.HttpsURLConnection;  
 import javax.net.ssl.KeyManagerFactory;  
 import javax.net.ssl.SSLContext;  
 import javax.net.ssl.SSLSocketFactory;  
 import javax.net.ssl.TrustManagerFactory;  
   
 /** 
  * 证书组件 
  *  
  * @author 梁栋 
  * @version 1.0 
  * @since 1.0 
  */  
 public abstract class CertificateCoder extends Coder {  
   
     /** 
      * Java密钥库(Java Key Store，JKS)KEY_STORE 
      */  
     public static final String KEY_STORE = "JKS";  
   
     public static final String X509 = "X.509";  
     public static final String SunX509 = "SunX509";  
     public static final String SSL = "SSL";  
   
     /** 
      * 由KeyStore获得私钥 
      *  
      * @param keyStorePath 
      * @param alias 
      * @param password 
      * @return 
      * @throws Exception 
      */  
     private static PrivateKey getPrivateKey(String keyStorePath, String alias,  
             String password) throws Exception {  
         KeyStore ks = getKeyStore(keyStorePath, password);  
         PrivateKey key = (PrivateKey) ks.getKey(alias, password.toCharArray());  
         return key;  
     }  
   
     /** 
      * 由Certificate获得公钥 
      *  
      * @param certificatePath 
      * @return 
      * @throws Exception 
      */  
     private static PublicKey getPublicKey(String certificatePath)  
             throws Exception {  
         Certificate certificate = getCertificate(certificatePath);  
         PublicKey key = certificate.getPublicKey();  
         return key;  
     }  
   
     /** 
      * 获得Certificate 
      *  
      * @param certificatePath 
      * @return 
      * @throws Exception 
      */  
     private static Certificate getCertificate(String certificatePath)  
             throws Exception {  
         CertificateFactory certificateFactory = CertificateFactory  
                 .getInstance(X509);  
         FileInputStream in = new FileInputStream(certificatePath);  
   
         Certificate certificate = certificateFactory.generateCertificate(in);  
         in.close();  
   
         return certificate;  
     }  
   
     /** 
      * 获得Certificate 
      *  
      * @param keyStorePath 
      * @param alias 
      * @param password 
      * @return 
      * @throws Exception 
      */  
     private static Certificate getCertificate(String keyStorePath,  
             String alias, String password) throws Exception {  
         KeyStore ks = getKeyStore(keyStorePath, password);  
         Certificate certificate = ks.getCertificate(alias);  
   
         return certificate;  
     }  
   
     /** 
      * 获得KeyStore 
      *  
      * @param keyStorePath 
      * @param password 
      * @return 
      * @throws Exception 
      */  
     private static KeyStore getKeyStore(String keyStorePath, String password)  
             throws Exception {  
         FileInputStream is = new FileInputStream(keyStorePath);  
         KeyStore ks = KeyStore.getInstance(KEY_STORE);  
         ks.load(is, password.toCharArray());  
         is.close();  
         return ks;  
     }  
   
     /** 
      * 私钥加密 
      *  
      * @param data 
      * @param keyStorePath 
      * @param alias 
      * @param password 
      * @return 
      * @throws Exception 
      */  
     public static byte[] encryptByPrivateKey(byte[] data, String keyStorePath,  
             String alias, String password) throws Exception {  
         // 取得私钥  
         PrivateKey privateKey = getPrivateKey(keyStorePath, alias, password);  
   
         // 对数据加密  
         Cipher cipher = Cipher.getInstance(privateKey.getAlgorithm());  
         cipher.init(Cipher.ENCRYPT_MODE, privateKey);  
   
         return cipher.doFinal(data);  
   
     }  
   
     /** 
      * 私钥解密 
      *  
      * @param data 
      * @param keyStorePath 
      * @param alias 
      * @param password 
      * @return 
      * @throws Exception 
      */  
     public static byte[] decryptByPrivateKey(byte[] data, String keyStorePath,  
             String alias, String password) throws Exception {  
         // 取得私钥  
         PrivateKey privateKey = getPrivateKey(keyStorePath, alias, password);  
   
         // 对数据加密  
         Cipher cipher = Cipher.getInstance(privateKey.getAlgorithm());  
         cipher.init(Cipher.DECRYPT_MODE, privateKey);  
   
         return cipher.doFinal(data);  
   
     }  
   
     /** 
      * 公钥加密 
      *  
      * @param data 
      * @param certificatePath 
      * @return 
      * @throws Exception 
      */  
     public static byte[] encryptByPublicKey(byte[] data, String certificatePath)  
             throws Exception {  
   
         // 取得公钥  
         PublicKey publicKey = getPublicKey(certificatePath);  
         // 对数据加密  
         Cipher cipher = Cipher.getInstance(publicKey.getAlgorithm());  
         cipher.init(Cipher.ENCRYPT_MODE, publicKey);  
   
         return cipher.doFinal(data);  
   
     }  
   
     /** 
      * 公钥解密 
      *  
      * @param data 
      * @param certificatePath 
      * @return 
      * @throws Exception 
      */  
     public static byte[] decryptByPublicKey(byte[] data, String certificatePath)  
             throws Exception {  
         // 取得公钥  
         PublicKey publicKey = getPublicKey(certificatePath);  
   
         // 对数据加密  
         Cipher cipher = Cipher.getInstance(publicKey.getAlgorithm());  
         cipher.init(Cipher.DECRYPT_MODE, publicKey);  
   
         return cipher.doFinal(data);  
   
     }  
   
     /** 
      * 验证Certificate 
      *  
      * @param certificatePath 
      * @return 
      */  
     public static boolean verifyCertificate(String certificatePath) {  
         return verifyCertificate(new Date(), certificatePath);  
     }  
   
     /** 
      * 验证Certificate是否过期或无效 
      *  
      * @param date 
      * @param certificatePath 
      * @return 
      */  
     public static boolean verifyCertificate(Date date, String certificatePath) {  
         boolean status = true;  
         try {  
             // 取得证书  
             Certificate certificate = getCertificate(certificatePath);  
             // 验证证书是否过期或无效  
             status = verifyCertificate(date, certificate);  
         } catch (Exception e) {  
             status = false;  
         }  
         return status;  
     }  
   
     /** 
      * 验证证书是否过期或无效 
      *  
      * @param date 
      * @param certificate 
      * @return 
      */  
     private static boolean verifyCertificate(Date date, Certificate certificate) {  
         boolean status = true;  
         try {  
             X509Certificate x509Certificate = (X509Certificate) certificate;  
             x509Certificate.checkValidity(date);  
         } catch (Exception e) {  
             status = false;  
         }  
         return status;  
     }  
   
     /** 
      * 签名 
      *  
      * @param keyStorePath 
      * @param alias 
      * @param password 
      *  
      * @return 
      * @throws Exception 
      */  
     public static String sign(byte[] sign, String keyStorePath, String alias,  
             String password) throws Exception {  
         // 获得证书  
         X509Certificate x509Certificate = (X509Certificate) getCertificate(  
                 keyStorePath, alias, password);  
         // 获取私钥  
         KeyStore ks = getKeyStore(keyStorePath, password);  
         // 取得私钥  
         PrivateKey privateKey = (PrivateKey) ks.getKey(alias, password  
                 .toCharArray());  
   
         // 构建签名  
         Signature signature = Signature.getInstance(x509Certificate  
                 .getSigAlgName());  
         signature.initSign(privateKey);  
         signature.update(sign);  
         return encryptBASE64(signature.sign());  
     }  
   
     /** 
      * 验证签名 
      *  
      * @param data 
      * @param sign 
      * @param certificatePath 
      * @return 
      * @throws Exception 
      */  
     public static boolean verify(byte[] data, String sign,  
             String certificatePath) throws Exception {  
         // 获得证书  
         X509Certificate x509Certificate = (X509Certificate) getCertificate(certificatePath);  
         // 获得公钥  
         PublicKey publicKey = x509Certificate.getPublicKey();  
         // 构建签名  
         Signature signature = Signature.getInstance(x509Certificate  
                 .getSigAlgName());  
         signature.initVerify(publicKey);  
         signature.update(data);  
   
         return signature.verify(decryptBASE64(sign));  
   
     }  
   
     /** 
      * 验证Certificate 
      *  
      * @param keyStorePath 
      * @param alias 
      * @param password 
      * @return 
      */  
     public static boolean verifyCertificate(Date date, String keyStorePath,  
             String alias, String password) {  
         boolean status = true;  
         try {  
             Certificate certificate = getCertificate(keyStorePath, alias,  
                     password);  
             status = verifyCertificate(date, certificate);  
         } catch (Exception e) {  
             status = false;  
         }  
         return status;  
     }  
   
     /** 
      * 验证Certificate 
      *  
      * @param keyStorePath 
      * @param alias 
      * @param password 
      * @return 
      */  
     public static boolean verifyCertificate(String keyStorePath, String alias,  
             String password) {  
         return verifyCertificate(new Date(), keyStorePath, alias, password);  
     }  
   
     /** 
      * 获得SSLSocektFactory 
      *  
      * @param password 
      *            密码 
      * @param keyStorePath 
      *            密钥库路径 
      *  
      * @param trustKeyStorePath 
      *            信任库路径 
      * @return 
      * @throws Exception 
      */  
     private static SSLSocketFactory getSSLSocketFactory(String password,  
             String keyStorePath, String trustKeyStorePath) throws Exception {  
         // 初始化密钥库  
         KeyManagerFactory keyManagerFactory = KeyManagerFactory  
                 .getInstance(SunX509);  
         KeyStore keyStore = getKeyStore(keyStorePath, password);  
         keyManagerFactory.init(keyStore, password.toCharArray());  
   
         // 初始化信任库  
         TrustManagerFactory trustManagerFactory = TrustManagerFactory  
                 .getInstance(SunX509);  
         KeyStore trustkeyStore = getKeyStore(trustKeyStorePath, password);  
         trustManagerFactory.init(trustkeyStore);  
   
         // 初始化SSL上下文  
         SSLContext ctx = SSLContext.getInstance(SSL);  
         ctx.init(keyManagerFactory.getKeyManagers(), trustManagerFactory  
                 .getTrustManagers(), null);  
         SSLSocketFactory sf = ctx.getSocketFactory();  
   
         return sf;  
     }  
   
     /** 
      * 为HttpsURLConnection配置SSLSocketFactory 
      *  
      * @param conn 
      *            HttpsURLConnection 
      * @param password 
      *            密码 
      * @param keyStorePath 
      *            密钥库路径 
      *  
      * @param trustKeyStorePath 
      *            信任库路径 
      * @throws Exception 
      */  
     public static void configSSLSocketFactory(HttpsURLConnection conn,  
             String password, String keyStorePath, String trustKeyStorePath)  
             throws Exception {  
         conn.setSSLSocketFactory(getSSLSocketFactory(password, keyStorePath,  
                 trustKeyStorePath));  
     }  
 }  

增加了 configSSLSocketFactory方法供外界调用，该方法为HttpsURLConnection配置了SSLSocketFactory。当HttpsURLConnection配置了SSLSocketFactory后，我们就可以通过HttpsURLConnection的getInputStream、getOutputStream，像往常使用HttpURLConnection做操作了。尤其要说明一点，未配置SSLSocketFactory前，HttpsURLConnection的getContentLength()获得值永远都是 -1。

给出相应测试类：

     Java代码   
     
   
 import static org.junit.Assert.*;  
   
 import java.io.DataInputStream;  
 import java.io.InputStream;  
 import java.net.URL;  
   
 import javax.net.ssl.HttpsURLConnection;  
   
 import org.junit.Test;  
   
 /** 
  *  
  * @author 梁栋 
  * @version 1.0 
  * @since 1.0 
  */  
 public class CertificateCoderTest {  
     private String password = "123456";  
     private String alias = "www.zlex.org";  
     private String certificatePath = "d:/zlex.cer";  
     private String keyStorePath = "d:/zlex.keystore";  
     private String clientKeyStorePath = "d:/zlex-client.keystore";  
     private String clientPassword = "654321";  
   
     @Test  
     public void test() throws Exception {  
         System.err.println("公钥加密——私钥解密");  
         String inputStr = "Ceritifcate";  
         byte[] data = inputStr.getBytes();  
   
         byte[] encrypt = CertificateCoder.encryptByPublicKey(data,  
                 certificatePath);  
   
         byte[] decrypt = CertificateCoder.decryptByPrivateKey(encrypt,  
                 keyStorePath, alias, password);  
         String outputStr = new String(decrypt);  
   
         System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);  
   
         // 验证数据一致  
         assertArrayEquals(data, decrypt);  
   
         // 验证证书有效  
         assertTrue(CertificateCoder.verifyCertificate(certificatePath));  
   
     }  
   
     @Test  
     public void testSign() throws Exception {  
         System.err.println("私钥加密——公钥解密");  
   
         String inputStr = "sign";  
         byte[] data = inputStr.getBytes();  
   
         byte[] encodedData = CertificateCoder.encryptByPrivateKey(data,  
                 keyStorePath, alias, password);  
   
         byte[] decodedData = CertificateCoder.decryptByPublicKey(encodedData,  
                 certificatePath);  
   
         String outputStr = new String(decodedData);  
         System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);  
         assertEquals(inputStr, outputStr);  
   
         System.err.println("私钥签名——公钥验证签名");  
         // 产生签名  
         String sign = CertificateCoder.sign(encodedData, keyStorePath, alias,  
                 password);  
         System.err.println("签名:\r" + sign);  
   
         // 验证签名  
         boolean status = CertificateCoder.verify(encodedData, sign,  
                 certificatePath);  
         System.err.println("状态:\r" + status);  
         assertTrue(status);  
   
     }  
   
     @Test  
     public void testHttps() throws Exception {  
         URL url = new URL("https://www.zlex.org/examples/");  
         HttpsURLConnection conn = (HttpsURLConnection) url.openConnection();  
   
         conn.setDoInput(true);  
         conn.setDoOutput(true);  
   
         CertificateCoder.configSSLSocketFactory(conn, clientPassword,  
                 clientKeyStorePath, clientKeyStorePath);  
   
         InputStream is = conn.getInputStream();  
   
         int length = conn.getContentLength();  
   
         DataInputStream dis = new DataInputStream(is);  
         byte[] data = new byte[length];  
         dis.readFully(data);  
   
         dis.close();  
         System.err.println(new String(data));  
         conn.disconnect();  
     }  
 }  

注意 testHttps方法，几乎和我们往常做HTTP访问没有差别，我们来看控制台输出：

     Console代码   
     
   
 <!--  
   Licensed to the Apache Software Foundation (ASF) under one or more  
   contributor license agreements.  See the NOTICE file distributed with  
   this work for additional information regarding copyright ownership.  
   The ASF licenses this file to You under the Apache License, Version 2.0  
   (the "License"); you may not use this file except in compliance with  
   the License.  You may obtain a copy of the License at  
   
       http://www.apache.org/licenses/LICENSE-2.0  
   
   Unless required by applicable law or agreed to in writing, software  
   distributed under the License is distributed on an "AS IS" BASIS,  
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  
   See the License for the specific language governing permissions and  
   limitations under the License.  
 -->  
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">  
 <HTML><HEAD><TITLE>Apache Tomcat Examples</TITLE>  
 <META http-equiv=Content-Type content="text/html">  
 </HEAD>  
 <BODY>  
 <P>  
 <H3>Apache Tomcat Examples</H3>  
 <P></P>  
 <ul>  
 <li><a href="servlets">Servlets examples</a></li>  
 <li><a href="jsp">JSP Examples</a></li>  
 </ul>  
 </BODY></HTML>  

通过浏览器直接访问 https://www.zlex.org/examples/你也会获得上述内容。也就是说应用甲方作为服务器构建tomcat服务，乙方可以通过上述方式访问甲方受保护的SSL应用，并且不需要考虑具体的加密解密问题。甲乙双方可以经过相应配置，通过双方的tomcat配置有效的SSL服务，简化上述代码实现，完全通过证书配置完成SSL双向认证！

相关链接：
Java加密技术（一）——BASE64与单向加密算法MD5&SHA&MAC
Java加密技术（二）——对称加密DES&AES
Java加密技术（三）——PBE算法
 Java加密技术（四）——非对称加密算法RSA
Java加密技术（五）——非对称加密算法的由来
 Java加密技术（六）——数字签名算法DSA
Java加密技术（七）——非对称加密算法最高ECC
Java加密技术（八）——数字证书
 Java加密技术（九）——初探SSL
Java加密技术（十）——单向认证
 Java加密技术（十一）——双向认证
 Java加密技术（十二）——*.PFX(*.p12)&个人信息交换文件

查看图片附件

17
顶

0
踩

分享到：

Java加密技术（十）——单向认证 | 我的职业生涯（四）路

2009-05-28 09:25
浏览 31874
评论(16)
收藏
分类:编程语言
相关推荐

参考知识库

Java SE知识库 10863 关注 | 450 收录

Java Web知识库 11242 关注 | 1121 收录

Java EE知识库 2779 关注 | 616 收录

JavaScript知识库 3096 关注 | 825 收录

16 楼 wang_he_all_5200 2016-03-23 引用

ak23173969 写道

楼主,我这边出现两个个问题
具体情况是
第一个是我配置tomact后,浏览器并没有看到什么变化,我这边的证书状态是不受信任的

第二个就是测试类中的出现了clientKeyStorePath 文件的路径,但是之前并没有出现该文件啊

楼主要是有时间看到的话,请帮忙解答下
谢谢

同问请问你现在知道了么?

15 楼 llcc1 2016-01-21 引用

keytool -import -alias www.zlex.org -file d:/zlex.cer -keystore d:/zlex.keystore
将cer导入到keystore的作用是什么呢，直接用d:/zlex.keystore就可以了吧

14 楼 dunhanson 2015-02-24 引用

感谢博主的文章，总算是对RSA加密技术有所了解。项目上要用到，正在试验当中

13 楼 hanbaojun2013 2014-06-27 引用

Tomcat SSL configuration issue - java.io.IOException: jsse.invalid_ssl_conf
zl 报这个错，我是完全按照你的这个写的是什么情况，谢谢

12 楼 wjt9989 2014-03-06 引用

执行删除命令就可以了，类似：

keytool -delete -alias www.ef.org -keystore ef.keystore -storepass 123456

然后再导入就可以了，类似：
keytool -importcert -trustcacerts -alias www.ef.org -file ef.cer -keystore ef.keystore -storepass 123456

vinegardou 写道

我也出现了
认证回复与keystore中的认证是相同的
怎么解决这个问题呢？

11 楼 vinegardou 2013-10-11 引用

我也出现了
认证回复与keystore中的认证是相同的
怎么解决这个问题呢？

10 楼 ak23173969 2013-09-30 引用

9 楼愤怒的程序猿 2013-08-12 引用

LZ:keytool错误:java.lang.Exception:认证回复与keystore中的认证是相同的.这个错误如何解决呢？

8 楼 gwh_08 2013-01-23 引用

spiritfrog 写道

你好，我按照你的步骤，tomcat中增加了
<Connector
    SSLEnabled="true"
    URIEncoding="UTF-8"
    clientAuth="false"
    keystoreFile="conf/zlex.keystore"
    keystorePass="123456"
    maxThreads="150"
    port="443"
    protocol="HTTP/1.1"
    scheme="https"
    secure="true"
    sslProtocol="TLS" />
但启动tomcat就报错了：
严重: Catalina.start:
LifecycleException: service.getName(): "Catalina"; Protocol handler start fail
ed: java.io.IOException: SSL configuration is invalid due to No available certif
icate or key corresponds to the SSL cipher suites which are enabled.
        at org.apache.catalina.connector.Connector.start(Connector.java:1097)
        at org.apache.catalina.core.StandardService.start(StandardService.java:4
57)
        at org.apache.catalina.core.StandardServer.start(StandardServer.java:700
)
        at org.apache.catalina.startup.Catalina.start(Catalina.java:552)
        at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
        at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.
java:39)
        at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAcces
sorImpl.java:25)
        at java.lang.reflect.Method.invoke(Method.java:597)
        at org.apache.catalina.startup.Bootstrap.start(Bootstrap.java:295)
        at org.apache.catalina.startup.Bootstrap.main(Bootstrap.java:433)
2010-2-26 16:01:20 org.apache.catalina.startup.Catalina start

请问这是怎么弄呢？

我也遇到这个问题了，如何解决啊？求解

7 楼 chl19871024 2010-03-02 引用

认证回复与keystore中的认证是相同的？这是什么错误。。

6 楼 spiritfrog 2010-02-26 引用

刚把域名换成了localhost，重新生成keystore和cer，就可以了。
谢谢。
但不清楚

CertificateCoder.configSSLSocketFactory(conn, clientPassword,
clientKeyStorePath, clientKeyStorePath);

里面的clientKeyStorePath是什么意思。。

5 楼 spiritfrog 2010-02-26 引用

4 楼 snowolf 2009-12-09 引用

angi0003 写道

请问clientAuth="false"是什么意思？

不要求做客户端证书验证。

3 楼 angi0003 2009-12-08 引用

请问clientAuth="false"是什么意思？

2 楼 treblesoftware 2009-05-30 引用

支持一下Lz，大概的看了一下，写的很漂亮！

1 楼 yinishao 2009-05-28 引用

LZ，你太厉害了！！！

你脑袋里装了多少东西啊？！

yangcbyang

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java加密技术（九）——初探SSL

在Java加密技术（八）中，我们模拟了一个基于RSA非对称加密网络的安全通信。现在我们深度了解一下现有的安全网络通信——SSL。我们需要构建一个由CA机构签发的有效证书，这里我们使用上文中生成的自签名证书zlex.cer 这里，我们将证书导入到我们的密钥库。 Shell代码 keytool -import -alias www.zlex.
复制链接

扫一扫