BlogJava-少年阿宾-随笔分类-HTTPS

Http Https Webservice

abin — Sun, 10 May 2015 03:27:00 GMT

1.Http作为web服务的首选协议，居有4大优点：
   1）http非常简单，以纯文本(超文本)形式编码的请求和响应组成
   2）http是无状态的。一旦发送了一个http请求，客户和服务器之间的连接信息就会被释放，有利于减少服务器资源的消耗。
   3）http的运行端口80，在大多数防火墙上是公开的
   4）行业认可。
但是Http的缺点：
   1）缺少对异步消息的支持
   2）消息传输的不可靠性

web service相对http (post/get)有好处吗？

1.接口中实现的方法和要求参数一目了然

2.不用担心大小写问题

3.不用担心中文urlencode问题

4.代码中不用多次声明认证(账号,密码)参数

5.传递参数可以为数组，对象等...

http和webservice的区别：
1、http是采用get，post等方式传输数据，而webservice是采用xml格式打包数据，传输是基于http协议进行传输。
2、http直接传输数据，而webservice是采用xml编解码数据，所以能速度上面有些慢。
3、webservice可以直接传输数组或者对象的数据格式，实际现在常用的http+json也可以的，只是需要进行字符串和各种格式的转换。
4、http传输占用的带宽要比webservice占用的带宽少。
5、webservice支持用户权限的验证，而http不支持直接的用户权限验证。
6、webservice接口中实现的方法和要求参数一目了然。

HTTPS和HTTP的区别：
https协议需要到ca申请证书，一般免费证书很少，需要交费。
http是超文本传输协议，信息是明文传输，https 则是具有安全性的ssl加密传输协议
http和https使用的是完全不同的连接方式用的端口也不一样,前者是80,后者是443。
http的连接很简单,是无状态的
HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、身份认证的网络协议要比http协议安全

SSL协议基础

SSL协议位于TCP/IP协议与各种应用层协议之间，本身又分为两层：

SSL记录协议(SSL Record Protocol)：建立在可靠传输层协议(TCP)之上，为上层协议提供数据封装、压缩、加密等基本功能。

SSL握手协议(SSL Handshake Procotol)：在SSL记录协议之上，用于实际数据传输前，通讯双方进行身份认证、协商加密算法、交换加密密钥等。

HTTPS通信过程：

1.在服务器端存在一个公钥及私钥

2.客户端从服务器取得这个公钥

3.客户端产生一个随机的密钥

4.客户端通过公钥对密钥加密（非对称加密）

5.客户端发送到服务器端

6.服务器端接受这个密钥并且以后的服务器端和客户端的数据全部通过这个密钥加密（对称加密）

abin 2015-05-10 11:27 发表评论

web.xml中配置http访问转向https

abin — Sun, 06 Jan 2013 13:28:00 GMT

1.tomcat下所有应用都强制https访问

在tomcat\conf\web.xml中的后面加上以下配置:

CLIENT-CERT

Client Cert Users-only Area

SSL

CONFIDENTIAL

2.单个应用强制https访问

WEB-INF/web.xml的后面加上以下配置:

CLIENT-CERT

Client Cert Users-only Area

SSL

CONFIDENTIAL

abin 2013-01-06 21:28 发表评论

HttpClient 实现跳转请求

abin — Thu, 27 Sep 2012 12:31:00 GMT

实现servlet的跳转，以输入流的形式来传输数据

测试UnionPayServlet的httpClient测试类：
package com.abin.lee.https;

import java.io.IOException;

import java.io.OutputStream;

import java.io.OutputStreamWriter;

import java.io.Writer;

import junit.framework.TestCase;

import org.apache.http.HttpEntity;

import org.apache.http.HttpResponse;

import org.apache.http.client.HttpClient;

import org.apache.http.client.methods.HttpPost;

import org.apache.http.entity.ContentProducer;

import org.apache.http.entity.EntityTemplate;

import org.apache.http.impl.client.DefaultHttpClient;

import org.apache.http.util.EntityUtils;

import org.junit.Test;

public class HttpClientTest extends TestCase {

private static final String Url = "http://localhost:9090/Spa/UnionPayServlet";

@Test

public void testHttpClient() throws Exception {

HttpClient client = new DefaultHttpClient();

HttpPost post = new HttpPost(Url);

ContentProducer create = new ContentProducer() {

public void writeTo(OutputStream outstream) throws IOException {

Writer writer = new OutputStreamWriter(outstream, "UTF-8");

writer.write("start");

writer.flush();

writer.close();

}

};

HttpEntity request = new EntityTemplate(create);

post.setEntity(request);

HttpResponse response = client.execute(post);

HttpEntity entity = response.getEntity();

String result = EntityUtils.toString(entity);

System.out.println("the last message is: "+result);

}

//被访问的servlet，也就是中间servlet

package org.litsoft.air.servlet;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.OutputStream;

import java.io.OutputStreamWriter;

import java.io.Writer;

import javax.servlet.ServletException;

import javax.servlet.ServletOutputStream;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.apache.http.HttpEntity;

import org.apache.http.HttpResponse;

import org.apache.http.client.HttpClient;

import org.apache.http.client.methods.HttpPost;

import org.apache.http.entity.ContentProducer;

import org.apache.http.entity.EntityTemplate;

import org.apache.http.impl.client.DefaultHttpClient;

import org.apache.http.util.EntityUtils;

public class UnionPayServlet extends HttpServlet {

private static final String Url = "http://localhost:9090/Spa/changeServlet";

@Override

protected void doPost(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

System.out.println("UnionPayServlet");

String result=null;

BufferedReader reader=new BufferedReader(new InputStreamReader(request.getInputStream()));

int num=0;

char[] buffer=new char[1024];

while((num=reader.read(buffer))!=-1){

result=new String(buffer,0,num);

}

System.out.println("from HttpCLient message is: ="+result);

final String transfer=result;

HttpClient client = new DefaultHttpClient();

HttpPost post = new HttpPost(Url);

ContentProducer create = new ContentProducer() {

public void writeTo(OutputStream outstream) throws IOException {

Writer writer = new OutputStreamWriter(outstream, "UTF-8");

writer.write(transfer);

writer.flush();

writer.close();

}

};

HttpEntity httpEntity = new EntityTemplate(create);

post.setEntity(httpEntity);

HttpResponse httpResponse = client.execute(post);

HttpEntity entity = httpResponse.getEntity();

String result1 = EntityUtils.toString(entity);

// System.out.println(result1);

ServletOutputStream out=response.getOutputStream();

BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(out));

writer.write("this message is received by UnionPayServlet is: "+result1);

writer.flush();

writer.close();

}

@Override

public void destroy() {

super.destroy();

}

//最终要处理的servlet

package org.litsoft.air.servlet;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

import java.io.PrintWriter;

import java.net.HttpURLConnection;

import java.net.URL;

import javax.servlet.ServletException;

import javax.servlet.ServletOutputStream;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.litsoft.air.unionpay.CreateJdomOne;

public class ChangeServlet extends HttpServlet {

@Override

protected void doPost(HttpServletRequest request,

HttpServletResponse response) throws ServletException, IOException {

// 接收Servlet传回来的信息

BufferedReader reader = new BufferedReader(new InputStreamReader(

request.getInputStream()));

String show = null;

StringBuffer stb = new StringBuffer();

while ((show = reader.readLine()) != null) {

stb.append(show);

}

System.out.println("from UnionPayServlet message is :" + stb.toString());

reader.close();

ServletOutputStream out=response.getOutputStream();

BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(out));

writer.write("this message is received by ChangeServlet is :"+stb.toString());

writer.flush();

writer.close();

}

//servlet的配置

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://java.sun.com/xml/ns/javaee

http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">

UnionPayServlet

org.litsoft.air.servlet.UnionPayServlet

UnionPayServlet

/UnionPayServlet

changeServlet

org.litsoft.air.servlet.ChangeServlet

changeServlet

/changeServlet

index.jsp

abin 2012-09-27 20:31 发表评论

HttpsUrlConnection https双向验证

abin — Wed, 26 Sep 2012 16:16:00 GMT

以下文章都是整合了好多网上的好多朋友的优秀资源，才写出来的。具体参考过谁的，我也记不清楚了。关于怎么生成https双向的证书，地址在这里：
http://www.blogjava.net/stevenjohn/archive/2012/08/22/385989.html
应该正常来说，按照这个教程做的话是没有任何问题的，但是也有些朋友出过问题，主要问题是在，把证书导入到浏览器里面的时候出的，注意这里。

我这里面的我都做过三四次了，基本没啥问题。但也不排除不会不出问题。

由于网上关于httpCilent来测试调用HTTPS的例子较少，经过在度娘和谷爹的查找，总算是也找到了一篇文章，参考以后，做出来一个测试类，在我机器上面是能够跑通的。具体地址：http://www.blogjava.net/stevenjohn/archive/2012/09/27/388646.html

//首先说一下，这个是我随便写的一个发布到tomcat的httpsUrlConnection的Servlet服务，主要是用来测试一下https双向验证的，现在网上好多的文章都是https单向验证的Java代码，我在网上看过好多，但是好多都是半成品，然后总结了一下，在自己的机器上面是完全能够跑通的，在这里做个笔记，以后用得着的时候来拿：

package com.abin.lee.https;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.PrintWriter;

import java.util.Enumeration;

import java.util.Map;

import javax.servlet.ServletException;

import javax.servlet.ServletOutputStream;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

@SuppressWarnings("serial")

public class ReceiveHttpsUrlConnectionRequest extends HttpServlet {

public void service(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

System.out.println("receive https request");
                /**这个主要是接收，由对方给以POST形式发过来的内容，这种内容不是以key-value的形式发的，而是直接通过Java的
                *string content="test https double auth";
*BufferedWriter writer = new BufferedWriter();
*writer.writer(content.getBytes());
*通过这种形式发过来的内容的接收，由于直接放到request里面发送过来的，所以的从request里面来接收。
                *之前做银联的手机支付的时候也是这么传递参数的。
*/

BufferedReader reader=new BufferedReader(new InputStreamReader(request.getInputStream()));

String line=null;

StringBuffer stb=new StringBuffer();
//循环的一行一行的读取内容
while((line=reader.readLine())!=null){

stb.append(line);

}
//打印读取到的内容。

System.out.println("stb="+stb.toString());
//给调用者返回内容

PrintWriter write=response.getWriter();

write.write("receive HttpsUrlConnection success");

write.flush();

write.close();

}

//这个是在web工程里面的web.xml里面配置的发布的servlet服务
//web.xml

httpsUrlConnectionRequest

com.abin.lee.https.ReceiveHttpsUrlConnectionRequest

httpsUrlConnectionRequest

/httpsUrlConnectionRequest

//HttpsUrlConnection测试类

package com.abin.lee.test;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.OutputStream;

import java.net.URL;

import java.util.Date;

import javax.net.ssl.HostnameVerifier;

import javax.net.ssl.HttpsURLConnection;

import javax.net.ssl.SSLSession;

import junit.framework.TestCase;

import org.junit.Before;

import org.junit.Test;

public class HttpsUrlConnectionClient extends TestCase {

// 客户端密钥库

private String sslKeyStorePath;

private String sslKeyStorePassword;

private String sslKeyStoreType;

// 客户端信任的证书

private String sslTrustStore;

private String sslTrustStorePassword;
//上面发布的servlet请求地址

private String httpsUrlConnectionUrl = "https://localhost:8443/global/httpsUrlConnectionRequest";

@Before

public void setUp() {
//这是密钥库
sslKeyStorePath = "D:\\home\\tomcat.keystore";

sslKeyStorePassword = "stevenjohn";

sslKeyStoreType = "JKS"; // 密钥库类型，有JKS PKCS12等
//信任库，这里需要服务端来新人客户端才能调用，因为这个我是配置的https双向验证，不但是要客户端信任服务端，服务端也要信任客户端。

sslTrustStore = "D:\\home\\tomcat.keystore";

sslTrustStorePassword = "stevenjohn";

System.setProperty("javax.net.ssl.keyStore", sslKeyStorePath);

System.setProperty("javax.net.ssl.keyStorePassword",

sslKeyStorePassword);

System.setProperty("javax.net.ssl.keyStoreType", sslKeyStoreType);

// 设置系统参数

System.setProperty("javax.net.ssl.trustStore", sslTrustStore);

System.setProperty("javax.net.ssl.trustStorePassword",

sslTrustStorePassword);

System.setProperty("java.protocol.handler.pkgs", "sun.net.www.protocol");

}

@Test

public void testHttpsUrlConnectionClient() {

try {

URL url = new URL(httpsUrlConnectionUrl);
//对于主机名的验证，因为配置服务器端的tomcat.keystore的证书的时候，是需要填写用户名的，一般用户名来说是本地ip地址，或者本地配置的域名
HostnameVerifier hv = new HostnameVerifier() {

public boolean verify(String urlHostName, SSLSession session) {

return true;

}

};

HttpsURLConnection.setDefaultHostnameVerifier(hv);
//编写HttpsURLConnection 的请求对象，这里需要注意HttpsURLConnection 比我们平时用的HttpURLConnection对了一个s，因为https是也是遵循http协议的，并且是采用ssl这个安全套接字来传输信息的，但是也有可能遭到黑客的攻击

HttpsURLConnection connection = (HttpsURLConnection) url

.openConnection();

connection.setRequestProperty("Content-Type", "text/xml");

connection.setDoOutput(true);

connection.setDoInput(true);
//设置请求方式为post,这里面当然也可以用get，但是我这里必须用post
connection.setRequestMethod("POST");

connection.setUseCaches(false);

connection.setReadTimeout(30000);

String user="abin";

String pwd="abing";

String request="user="+user+"&pwd="+pwd;

OutputStream out = connection.getOutputStream();
//下面的这句话是给servlet发送请求内容

out.write(request.getBytes());

out.flush();

out.close();

//接收请求的返回值

BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));

StringBuffer stb = new StringBuffer();

String line;

while ((line = reader.readLine()) != null) {

stb.append(line);

}

Integer statusCode = connection.getResponseCode();

System.out.println("返回状态码:" + statusCode);

reader.close();

connection.disconnect();

} catch (IOException e) {

e.printStackTrace();

}

//发布好了服务，你需要在tomcat里面配置好了https服务的端口才能使用。
//tomcat配置文件：

connectionTimeout="20000"

redirectPort="8443" />

/**关于https端口的说明，银联一般用的都是0--9 443,这种类型的端口，第一位是0--9中的任意一位，然后后面三位是443，而通过我的测试，发觉随便一个端口号都可 * 以的，只要不和你机器的其他端口冲突就行，911,95553这些端口都是可以滴。
*clientAuth="true" 这里设置为false是https单向认证，设置为true则是https双向认证
*/

SSLEnabled="true" maxThreads="150" scheme="https"

secure="true" clientAuth="true" sslProtocol="TLS"

keystoreFile="D:\\home\\tomcat.keystore" keystorePass="stevenjohn" //密钥库

truststoreFile="D:\\home\\tomcat.keystore" truststorePass="stevenjohn" />//信任库

abin 2012-09-27 00:16 发表评论

HttpClient https双向验证

abin — Wed, 26 Sep 2012 16:11:00 GMT

已经发布的准备要测试的https服务：

package com.abin.lee.https;

import java.io.IOException;

import java.io.PrintWriter;

import java.util.Map;

import javax.servlet.ServletException;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

@SuppressWarnings("serial")

public class ReceiveHttpClientRequest extends HttpServlet {

public void service(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

System.out.println("receive https request");

Map map=request.getParameterMap();

String user=(((Object[])map.get("user"))[0]).toString();

System.out.println("user="+user);

String pwd=(((Object[])map.get("pwd"))[0]).toString();

System.out.println("pwd="+pwd);

//给调用者返回值

PrintWriter write=response.getWriter();

write.write("receive HttpClient success");

write.flush();

write.close();

}

//web.xml

httpsClientRequest

com.abin.lee.https.ReceiveHttpClientRequest

httpsClientRequest

/httpsClientRequest

//HttpClient测试类

package com.abin.lee.test;

import java.io.BufferedReader;

import java.io.FileInputStream;

import java.io.InputStreamReader;

import java.security.KeyStore;

import java.util.ArrayList;

import java.util.List;

import javax.net.ssl.KeyManagerFactory;

import javax.net.ssl.SSLContext;

import javax.net.ssl.TrustManager;

import javax.net.ssl.TrustManagerFactory;

import junit.framework.TestCase;

import org.apache.http.HttpResponse;

import org.apache.http.NameValuePair;

import org.apache.http.client.HttpClient;

import org.apache.http.client.entity.UrlEncodedFormEntity;

import org.apache.http.client.methods.HttpPost;

import org.apache.http.conn.scheme.Scheme;

import org.apache.http.conn.ssl.SSLSocketFactory;

import org.apache.http.impl.client.DefaultHttpClient;

import org.apache.http.message.BasicNameValuePair;

import org.apache.http.protocol.HTTP;

import org.junit.Before;

import org.junit.Test;

public class HttpsClient extends TestCase {

private String httpUrl = "https://localhost:8443/global/httpsClientRequest";

// 客户端密钥库

private String sslKeyStorePath;

private String sslKeyStorePassword;

private String sslKeyStoreType;

// 客户端信任的证书

private String sslTrustStore;

private String sslTrustStorePassword;

@Before

public void setUp() {

sslKeyStorePath = "D:\\home\\tomcat.keystore";

sslKeyStorePassword = "stevenjohn";

sslKeyStoreType = "JKS"; // 密钥库类型，有JKS PKCS12等

sslTrustStore = "D:\\home\\tomcat.keystore";

sslTrustStorePassword = "stevenjohn";

System.setProperty("javax.net.ssl.keyStore", sslKeyStorePath);

System.setProperty("javax.net.ssl.keyStorePassword",

sslKeyStorePassword);

System.setProperty("javax.net.ssl.keyStoreType", sslKeyStoreType);

// 设置系统参数

System.setProperty("javax.net.ssl.trustStore", sslTrustStore);

System.setProperty("javax.net.ssl.trustStorePassword",

sslTrustStorePassword);

}

@Test

public void testHttpsClient() {

SSLContext sslContext = null;

try {

KeyStore kstore = KeyStore.getInstance("jks");

kstore.load(new FileInputStream(sslKeyStorePath),

sslKeyStorePassword.toCharArray());

KeyManagerFactory keyFactory = KeyManagerFactory

.getInstance("sunx509");

keyFactory.init(kstore, sslKeyStorePassword.toCharArray());

KeyStore tstore = KeyStore.getInstance("jks");

tstore.load(new FileInputStream(sslTrustStore),

sslTrustStorePassword.toCharArray());

TrustManager[] tm;

TrustManagerFactory tmf = TrustManagerFactory

.getInstance("sunx509");

tmf.init(tstore);

tm = tmf.getTrustManagers();

sslContext = SSLContext.getInstance("SSL");

sslContext.init(keyFactory.getKeyManagers(), tm, null);

} catch (Exception e) {

e.printStackTrace();

}

try {

HttpClient httpClient = new DefaultHttpClient();

SSLSocketFactory socketFactory = new SSLSocketFactory(sslContext);

Scheme sch = new Scheme("https", 8443, socketFactory);

httpClient.getConnectionManager().getSchemeRegistry().register(sch);

HttpPost httpPost = new HttpPost(httpUrl);

List nvps = new ArrayList();

nvps.add(new BasicNameValuePair("user", "abin"));

nvps.add(new BasicNameValuePair("pwd", "abing"));

httpPost.setEntity(new UrlEncodedFormEntity(nvps, HTTP.UTF_8));

HttpResponse httpResponse = httpClient.execute(httpPost);

String spt = System.getProperty("line.separator");

BufferedReader buffer = new BufferedReader(new InputStreamReader(

httpResponse.getEntity().getContent()));

StringBuffer stb=new StringBuffer();

String line=null;

while((line=buffer.readLine())!=null){

stb.append(line);

}

buffer.close();

String result=stb.toString();

System.out.println("result="+result);

} catch (Exception e) {

e.printStackTrace();

}

//tomcat配置文件：（前提是https双向验证证书生成的没有一点问题）

SSLEnabled="true" maxThreads="150" scheme="https"

secure="true" clientAuth="true" sslProtocol="TLS"

keystoreFile="D:\\home\\tomcat.keystore" keystorePass="stevenjohn"

truststoreFile="D:\\home\\tomcat.keystore" truststorePass="stevenjohn" />

abin 2012-09-27 00:11 发表评论

Tomcat配置HTTPS方式(单向)

abin — Wed, 26 Sep 2012 08:34:00 GMT

简要记录主要步骤备忘

1、进入到jdk下的bin目录

2、输入如下指令

keytool -v -genkey -alias tomcat -keyalg RSA -keystore d:/tomcat.keystore -validity 36500

附：

d:/tomcat.keystore是将生成的tomcat.keystore放到d盘根目录下。

"-validity 36500”含义是证书有效期，36500表示100年，默认值是90天

注意若要放到c盘，在win7系统下，需要以管理员身份进入到命令行中进行操作，否则是无法创建tomcat.keystore的。本例放到d盘下。
如何以管理员身份进入到命令行下呢？开始->搜索框中输入cmd->等待（注意不回车）->出现cmd.exe->右键“以管理员身份运行”即可。

3、输入keystore密码

密码任意，此处以123456为例，要记住这个密码，之后在进行server.xml配置时需要使用。

4、输入名字、组织单位、组织、市、省、国家等信息

注意事项：

A、Enter keystore password：此处需要输入大于6个字符的字符串

B、“What is your first and last name?”这是必填项，并且必须是TOMCAT部署主机的域名或者IP[如：gbcom.com 或者 10.1.25.251]，就是你将来要在浏览器中输入的访问地址

C、“What is the name of your organizational unit?”、“What is the name of your organization?”、“What is the name of your City or Locality?”、“What is the name of your State or Province?”、“What is the two-letter country code for this unit?”可以按照需要填写也可以不填写直接回车，在系统询问“correct?”时，对照输入信息，如果符合要求则使用键盘输入字母“y”，否则输入“n”重新填写上面的信息

D、Enter key password for ，这项较为重要，会在tomcat配置文件中使用，建议输入与keystore的密码一致，设置其它密码也可以

l 完成上述输入后，直接回车则在你在第二步中定义的位置找到生成的文件

5、输入之后会出现确认的提示

此时输入y，并回车。此时创建完成keystore。
进入到D盘根目录下可以看到已经生成的tomcat.xml

6、进入tomcat文件夹
找到conf目录下的sever.xml并进行编辑

7、编辑
     maxThreads="150" scheme="https" secure="true"
     clientAuth="false" keystoreFile="D:/AppServer/Tomcat/apache-tomcat-6.0.32/conf/tomcat.keystore"
     keystorePass="deleiguo" sslProtocol="TLS" />
注：
方框中的keystore的密码，就是刚才我们设置的“123456”.

编辑完成后关闭并保存sever.xml

8、Tomcat启动成功后，使用https://127.0.0.1:8443 访问页面

页面成功打开即tomcat下的https配置成功。

9、应用程序HTTP自动跳转到HTTPS

在应用程序中web.xml中加入：

SSL

CONFIDENTIAL

10、生成安全证书文件

keytool -export -alias tomcat -file D:/file.cer -keystore d:/tomcat.keystore -validity 36500

然后输入d:/tomcat.keystore中的keystore密码

-file D:/file.cer 即为生成的cer文件，可直接点击安装

11、注意事项：

（1）生成证书的时间，如果IE客户端所在机器的时间早于证书生效时间，或者晚于有效时间，IE会提示“该安全证书已到期或还未生效”

（2）如果IE提示“安全证书上的名称无效或者与站点名称不匹配”，则是由生成证书时填写的服务器所在主机的域名“您的名字与姓氏是什么？”/“What is your first and last name?”不正确引起的

12、遗留问题：

（1）如果AC主机不能通过域名查找，必须使用IP，但是这个IP只有在配置后才能确定，这样证书就必须在AC确定IP地址后才能生成

（2）证书文件只能绑定一个IP地址，假设有10.1.25.250 和 192.168.1.250 两个IP地址，在证书生成文件时，如使用了10.1.25.250，通过IE就只能使用10.1.25.250 来访问AC-WEB，192.168.1.250是无法访问AC-WEB的。

abin 2012-09-26 16:34 发表评论

Java Https单向，双向验证

abin — Sun, 23 Sep 2012 14:31:00 GMT

https一般来说有单项SSL和双向SSL连接之分。

单项SSL连接，也就是只是客户端验证服务器证书。tomcat中clientAuth="false"的时候，HTTPS单向验证如下：

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.URL;
import java.util.Date;
import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLSession;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

public class ClientSendData {
    static Log log = LogFactory.getLog(ClientSendData.class);
    // 客户端信任的证书
    private String sslTrustStore;
    private String sslTrustStorePassword;
    private String Url;

    //初始化数据
    public ClientSendData() {
        sslTrustStore = "D:/ssl/clientTrust.jks";
        sslTrustStorePassword = "123456";
        Url = "https://test.yihaodian.com:8443/ims/feedbackToPingAn_getData.action";
    }

    public String sendData(String data) {
        String receivedData = null;
        try {
            //设置系统参数
            System.setProperty("javax.net.ssl.trustStore", sslTrustStore);
            System.setProperty("javax.net.ssl.trustStorePassword",
                    sslTrustStorePassword);
            receivedData = send(Url, data);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return receivedData;
    }

    public static String send(String sendurl, String sendData)
            throws Exception {
        URL url = new URL(sendurl);
        HostnameVerifier hv = new HostnameVerifier() {
            public boolean verify(String urlHostName, SSLSession session) {
                return true;
            }
        };
        System.setProperty("java.protocol.handler.pkgs","sun.net.www.protocol");
        HttpsURLConnection.setDefaultHostnameVerifier(hv);
        Date current = new Date(System.currentTimeMillis());
        log.info("begint to open connection at " + current);
        HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
        Date end = new Date(System.currentTimeMillis());
        log.info("open connection ok at " + end + ",cost:"+ (end.getTime() - current.getTime()));
        connection.setRequestProperty("Content-Type", "text/xml");
        connection.setDoOutput(true);
        connection.setDoInput(true);
        connection.setRequestMethod("POST");
        connection.setUseCaches(false);
        connection.setReadTimeout(30000);
        byte data[] = sendData.getBytes();
        current = new Date(System.currentTimeMillis());
        log.info("[SSLIX]notifyEai,begint to write data at " + current);
        OutputStream out = connection.getOutputStream();
        out.write(data);
        end = new Date(System.currentTimeMillis());
        log.info("write data ok at " + end + ",cost:"
                + (end.getTime() - current.getTime()));
        StringBuffer receivedData = new StringBuffer();
        current = new Date(System.currentTimeMillis());
        log.info("begint to read data at " + current);
        InputStreamReader inReader = new InputStreamReader(connection
                .getInputStream(), "UTF-8");
        BufferedReader aReader = new BufferedReader(inReader);
        String aLine;
        while ((aLine = aReader.readLine()) != null) {
            receivedData.append(aLine);
        }
        end = new Date(System.currentTimeMillis());
        log.info("read data ok at " + end + ",cost:"
                + (end.getTime() - current.getTime()));

        log.info("开始返回状态码");
        Integer statusCode = connection.getResponseCode();
        log.info("返回状态码:" + statusCode);
        aReader.close();
        connection.disconnect();
        return receivedData.toString();
    }

    public static void main(String[] args) {
        ClientSendData t = new ClientSendData();
        t.sendData("测试SSL单项连接，向服务端发送数据!");
    }
}

单项认证时，只需要设置客户端信任的证书库就行。但是当是双向认证时，还需要设置客户端密钥库密码。

HTTPS双向验证代码如下：

public class ClientSendData {
    static Log log = LogFactory.getLog(EaiChannel.class);
    //客户端密钥库
    private String sslKeyStorePath;
    private String sslKeyStorePassword;
    private String sslKeyStoreType;
    // 客户端信任的证书
    private String sslTrustStore;
    private String sslTrustStorePassword;
    private String eaiUrl;

    //初始化数据
    public ClientSendData() {
        sslKeyStorePath = "D:/ssl/clientKeys.jks";
        sslKeyStorePassword     = "123456";
        sslKeyStoreType = "JKS"; //密钥库类型，有JKS PKCS12等
        sslTrustStore = "D:/ssl/clientTrust.jks";
        sslTrustStorePassword = "123456";
        eaiUrl = "https://test.yihaodian.com:8443/ims/feedbackToPingAn_getData.action";
    }

    public String sendData(String data) {
        String receivedData = null;
        try {

             System.setProperty("javax.net.ssl.keyStore", sslKeyStorePath);
             System.setProperty("javax.net.ssl.keyStorePassword",sslKeyStorePassword);
             System.setProperty("javax.net.ssl.keyStoreType", sslKeyStoreType);
            //设置系统参数
            System.setProperty("javax.net.ssl.trustStore", sslTrustStore);
            System.setProperty("javax.net.ssl.trustStorePassword",
                    sslTrustStorePassword);
            receivedData = send(eaiUrl, data);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return receivedData;
    }

    public static String send(String sendurl, String sendData)
            throws Exception {
        //和上面一样
    }

    public static void main(String[] args) {
        ClientSendData t = new ClientSendData();
        t.sendData("测试SSL双项连接，向服务端发送数据!");
    }
}

下面来说说可能会遇到的异常：

1. java.security.NoSuchAlgorithmException

一般来说是密钥库类型不对，如上面的sslKeyStoreType = "JKS" 却写成PKCS12。

也有可能是证书的问题。

2. java.net.UnknownHostException

服务端地址不对。

3.java.net.SocketException: Unexpected end of file from server

这个异常和客户端没有关系，说明已经发送成功。是服务端的问题。有可能是防火墙的原因，也可能是服务端没处理客户端的响应。

另外有人说当URL过长时也会发生此错误，当使用URL发送数据时，可以参考此意见。

4.java.io.IOException:server returned HTTP response code :500

这个异常是服务端代码的问题。服务端相应代码执行时抛出了异常。

最后如果返回的状态码是200 ，表示成功。

abin 2012-09-23 22:31 发表评论

Https ssl java

abin — Thu, 23 Aug 2012 05:54:00 GMT

http://www.iteye.com/topic/1125183
http://blog.sina.com.cn/s/blog_5f64eccd0100p0pc.html
http://www.iteye.com/topic/1125183
http://hi.baidu.com/zhouqiugang/blog/item/65c9e160177db3cc8cb10d86.html
http://blog.csdn.net/zrbin153/article/details/6026840
HttpClient访问https站点证书加载问题
http://237451446.blog.51cto.com/2307663/759338

HttpClient请求Https协议

http://www.blogjava.net/sxyx2008/archive/2011/07/08/353940.html

abin 2012-08-23 13:54 发表评论

keytool+tomcat配置HTTPS双向证书认证

abin — Wed, 22 Aug 2012 01:52:00 GMT

系统需求：

1、  Windows系统或Linux系统

2、  安装并配置JDK 1.6.0_13

3、  安装并配置Tomcat 6.0

第一步：为服务器生成证书

1、  Windows系统

“运行”控制台，进入%JAVA_HOME%/bin目录
使用keytool为Tomcat生成证书，假定目标机器的域名是“localhost”，keystore文件存放在“D:\home\tomcat.keystore”，口令为“password”，使用如下命令生成：

keytool -genkey -v -alias tomcat -keyalg RSA -keystore D:\home\tomcat.keystore -validity 36500

(参数简要说明：“D:\home\tomcat.keystore”含义是将证书文件的保存路径，证书文件名称是tomcat.keystore ；“-validity 36500”含义是证书有效期，36500表示100年，默认值是90天)

在命令行填写必要参数：

A、输入keystore密码：此处需要输入大于6个字符的字符串

B、“您的名字与姓氏是什么？”这是必填项，并且必须是TOMCAT部署主机的域名或者IP[如：gbcom.com 或者 10.1.25.251]（就是你将来要在浏览器中输入的访问地址），否则浏览器会弹出警告窗口，提示用户证书与所在域不匹配。在本地做开发测试时，应填入“localhost”

C、“你的组织单位名称是什么？”、“您的组织名称是什么？”、“您所在城市或区域名称是什么？”、“您所在的州或者省份名称是什么？”、“该单位的两字母国家代码是什么？”可以按照需要填写也可以不填写直接回车，在系统询问“正确吗？”时，对照输入信息，如果符合要求则使用键盘输入字母“y”，否则输入“n”重新填写上面的信息

D、输入的主密码，这项较为重要，会在tomcat配置文件中使用，建议输入与keystore的密码一致，设置其它密码也可以

完成上述输入后，直接回车则在你在第二步中定义的位置找到生成的文件

2、  Linux系统

“运行”控制台，进入%JAVA_HOME%/bin目录
使用如下命令生成：

./keytool -genkey -alias tomcat -keyalg RSA -keystore /usr/local/ac/web/tomcat.keystore -validity 36500

(参数简要说明：“/etc/tomcat.keystore”含义是将证书文件保存在路径/usr/local/ac/web/下，证书文件名称是tomcat.keystore ；“-validity 36500”含义是证书有效期，36500表示100年，默认值是90天)

在命令行填写必要参数：

A、Enter keystore password：此处需要输入大于6个字符的字符串

B、“What is your first and last name?”这是必填项，并且必须是TOMCAT部署主机的域名或者IP[如：gbcom.com 或者 10.1.25.251]，就是你将来要在浏览器中输入的访问地址

C、“What is the name of your organizational unit?”、“What is the name of your organization?”、“What is the name of your City or Locality?”、“What is the name of your State or Province?”、“What is the two-letter country code for this unit?”可以按照需要填写也可以不填写直接回车，在系统询问“correct?”时，对照输入信息，如果符合要求则使用键盘输入字母“y”，否则输入“n”重新填写上面的信息

D、Enter key password for ，这项较为重要，会在tomcat配置文件中使用，建议输入与keystore的密码一致，设置其它密码也可以

完成上述输入后，直接回车则在你在第二步中定义的位置找到生成的文件

第二步：为客户端生成证书

为浏览器生成证书，以便让服务器来验证它。为了能将证书顺利导入至IE和Firefox，证书格式应该是PKCS12，因此，使用如下命令生成：

keytool -genkey -v -alias mykey -keyalg RSA -storetype PKCS12 -keystore D:\home\mykey.p12

对应的证书库存放在“D:\home\mykey.p12”，客户端的CN可以是任意值。双击mykey.p12文件，即可将证书导入至浏览器（客户端）。

第三步：让服务器信任客户端证书

由于是双向SSL认证，服务器必须要信任客户端证书，因此，必须把客户端证书添加为服务器的信任认证。由于不能直接将PKCS12格式的证书库导入，必须先把客户端证书导出为一个单独的CER文件，使用如下命令：

keytool -export -alias mykey -keystore D:\home\mykey.p12 -storetype PKCS12 -storepass password -rfc -file D:\home\mykey.cer

通过以上命令，客户端证书就被我们导出到“D:\home\mykey.cer”文件了。下一步，是将该文件导入到服务器的证书库，添加为一个信任证书：

keytool -import -v -file D:\home\mykey.cer -keystore D:\home\tomcat.keystore

通过list命令查看服务器的证书库，可以看到两个证书，一个是服务器证书，一个是受信任的客户端证书：

keytool -list -keystore D:\home\tomcat.keystore

第四步：让客户端信任服务器证书

由于是双向SSL认证，客户端也要验证服务器证书，因此，必须把服务器证书添加到浏览的“受信任的根证书颁发机构”。由于不能直接将keystore格式的证书库导入，必须先把服务器证书导出为一个单独的CER文件，使用如下命令：

keytool -keystore D:\home\tomcat.keystore -export -alias tomcat -file D:\home\tomcat.cer

通过以上命令，服务器证书就被我们导出到“D:\home\tomcat.cer”文件了。双击tomcat.cer文件，按照提示安装证书，将证书填入到“受信任的根证书颁发机构”。

第四步：配置Tomcat服务器

打开Tomcat根目录下的/conf/server.xml，找到如下配置段，修改如下：

SSLEnabled="true" maxThreads="150" scheme="https"
secure="true" clientAuth="true" sslProtocol="TLS"
keystoreFile="D:\\home\\test.keystore" keystorePass="123456"
truststoreFile="D:\\home\\test.keystore" truststorePass="123456" />

属性说明：

clientAuth:设置是否双向验证，默认为false，设置为true代表双向验证
keystoreFile:服务器证书文件路径
keystorePass:服务器证书密码
truststoreFile:用来验证客户端证书的根证书，此例中就是服务器证书
truststorePass:根证书密码

第五步：测试

在浏览器中输入:https://localhost:8443/，会弹出选择客户端证书界面，点击“确定”，会进入tomcat主页，地址栏后会有“锁”图标，表示本次会话已经通过HTTPS双向验证，接下来的会话过程中所传输的信息都已经过SSL信息加密。

注意事项：貌似导入证书的时候，最好导入到“个人”那一栏里面，貌似客户端的用户名不填写也是可以的，或者随便填写。

http://licg1234.blog.163.com/blog/static/13908233320121165356868/

abin 2012-08-22 09:52 发表评论