// 初始化可以拖拽的Element的函数，与拖拽无关的我去掉了
  draggable(el) {
     // 公用的开始拖拽的函数
     this ._dragStart  =  start_Drag;
     // 公用的正在拖拽的函数
     this ._drag  =  when_Drag;
     // 公用的拖拽结束的函数
     this ._dragEnd  =  end_Drag;
     // 这个函数主要用来进行拖拽结束后的dom处理
     this ._afterDrag  =  after_Drag;
     // 是否正在被拖动，一开始当然没有被拖动
     this .isDragging  =   false ;
     // 将这个Element的this指针注册在elm这个变量里面，方便在自己的上下文以外调用自己的函数等，很常用的方法
     this .elm  =  el;
     // 触发拖拽的Element，在这里就是这个div上显示标题的那个div
     this .header  =  getElementById(el.id  +   " _h " );
     // 对于有i的element拖拽不同，这里检测一下并记录
     this .hasI  =   this .elm.getElementsByTagName( " I " ).length  >   0 ;
     // 如果找到了header就绑定drag相关的event
     if  ( this .header) {
         // 拖拽时的叉子鼠标指针
         this .header.style.cursor  =   " move " ;
         // 将函数绑定到header和element的this上，参照那个函数的说明
        Drag.init( this .header,  this .elm);
         // 下面三个语句将写好的三个函数绑定给这个elemnt的三个函数钩子上，也就实现了element从draggable继承可拖拽的函数
         this .elm.onDragStart  =  Util.bind( this ,  " _dragStart " );
         this .elm.onDrag  =  Util.bind( this ,  " _drag " );
         this .elm.onDragEnd  =  Util.bind( this ,  " _dragEnd " );
    }
};

// 可拖拽Element的原形，用来将event绑定到各个钩子，这部分市比较通用的，netvibes也是基本完全相同的实现
// 这部分推荐看dindin的这个，也会帮助理解，http://www.jroller.com/page/dindin/?anchor=pro_java_12
var  Drag  =  {
     // 对这个element的引用，一次只能拖拽一个Element
    obj: null ,
     // element是被拖拽的对象的引用，elementHeader就是鼠标可以拖拽的区域
    init:   (elementHeader, element) {
         // 将start绑定到down事件，按下鼠标触发start
        elementHeader.down  =  Drag.start;
         // 将element存到header的obj里面，方便header拖拽的时候引用
        elementHeader.obj  =  element;
         // 初始化绝对的坐标，因为不是position=absolute所以不会起什么作用，但是防止后面onDrag的时候parse出错了
         if  (isNaN(parseInt(element.style.left))) {
            element.style.left  =   " 0px " ;
        }
         if  (isNaN(parseInt(element.style.top))) {
            element.style.top  =   " 0px " ;
        }
         // 挂上空，初始化这几个成员，在Drag.init被调用后才帮定到实际的函数，可以参照draggable里面的内容
        element.onDragStart  =   new  ();
        element.onDragEnd  =   new  ();
        element.onDrag  =   new  ();
    },
     // 开始拖拽的绑定，绑定到鼠标的移动的event上
    start:   (event) {
         var  element  =  Drag.obj  =   this .obj;
         // 解决不同浏览器的event模型不同的问题
        event  =  Drag.fixE(event);
         // 看看是不是左键点击
         if  (event.which  !=   1 ) {
             // 除了左键都不起作用
             return   true ;
        }
         // 参照这个函数的解释，挂上开始拖拽的钩子
        element.onDragStart();
         // 记录鼠标坐标
        element.lastMouseX  =  event.clientX;
        element.lastMouseY  =  event.clientY;
         // 将Global的event绑定到被拖动的element上面来
        up  =  Drag.end;
        move  =  Drag.drag;
         return   false ;
    },
     // Element正在被拖动的函数
    drag:   (event) {
         // 解决不同浏览器的event模型不同的问题
        event  =  Drag.fixE(event);
         // 看看是不是左键点击
         if  (event.which  ==   0 ) {
             // 除了左键都不起作用
             return  Drag.end();
        }
         // 正在被拖动的Element
         var  element  =  Drag.obj;
         // 鼠标坐标
         var  _clientX  =  event.clientY;
         var  _clientY  =  event.clientX;
         // 如果鼠标没动就什么都不作
         if  (element.lastMouseX  ==  _clientY  &&  element.lastMouseY  ==  _clientX) {
             return   false ;
        }
         // 刚才Element的坐标
         var  _lastX  =  parseInt(element.style.top);
         var  _lastY  =  parseInt(element.style.left);
         // 新的坐标
         var  newX, newY;
         // 计算新的坐标：原先的坐标+鼠标移动的值差
        newX  =  _lastY  +  _clientY  -  element.lastMouseX;
        newY  =  _lastX  +  _clientX  -  element.lastMouseY;
         // 修改element的显示坐标
        element.style.left  =  newX  +   " px " ;
        element.style.top  =  newY  +   " px " ;
         // 记录element现在的坐标供下一次移动使用
        element.lastMouseX  =  _clientY;
        element.lastMouseY  =  _clientX;
         // 参照这个函数的解释，挂接上Drag时的钩子
        element.onDrag(newX, newY);
         return   false ;
    },
     // Element正在被释放的函数，停止拖拽
    end:   (event) {
         // 解决不同浏览器的event模型不同的问题
        event  =  Drag.fixE(event);
         // 解除对Global的event的绑定
        move  =   null ;
        up  =   null ;
         // 先记录下onDragEnd的钩子，好移除obj
         var  _onDragEndFuc  =  Drag.obj.onDragEnd();
         // 拖拽完毕，obj清空
        Drag.obj  =   null ;
         return  _onDragEndFuc;
    },
     // 解决不同浏览器的event模型不同的问题
    fixE:   (ig_) {
         if  ( typeof  ig_  ==   " undefined " ) {
            ig_  =  event;
        }
         if  ( typeof  ig_.layerX  ==   " undefined " ) {
            ig_.layerX  =  ig_.offsetX;
        }
         if  ( typeof  ig_.layerY  ==   " undefined " ) {
            ig_.layerY  =  ig_.offsetY;
        }
         if  ( typeof  ig_.which  ==   " undefined " ) {
            ig_.which  =  ig_.button;
        }
         return  ig_;
    }
};

// 下面是初始化的函数了，看看上面这些东西怎么被调用
var  _IG_initDrag  =     (el) {
     // column那个容器，在google里面就是那个table布局的tbody，netvibes用的<div>
    Util.rootElement  =  el;
     // 这个tbody的行
    Util._rows  =  Util.rootElement.tBodies[ 0 ].rows[ 0 ];
     // 列，google是3列，其实也可以更多
    Util.column  =  Util._rows.cells;
     // 用来存取可拖拽的对象
    Util.dragArray  =   new  Array();
     var  counter  =   0 ;
     for  ( var  i  =   0 ; i  <  Util.column.length; i ++ ) {
         // 搜索所有的column
         var  ele  =  Util.column[i];
         for  ( var  j  =   0 ; j  <  ele.childNodes.length; j ++ ) {
             // 搜索每一column里面的所有element
             var  ele1  =  ele.childNodes[j];
             // 如果是div就把它初始化为一个draggable对象
             if  (ele1.tagName  ==   " DIV " ) {
                Util.dragArray[counter]  =   new  draggable(ele1);
                counter ++ ;
            }
        }
    }
};

// google的页面里可以拖动的部分的id是"t_1"
// 挂载到，载入完毕执行。不过实际上google没有用。
// 而是写在页面最下面，异曲同工吧，也许直接写在页面是种怪癖，或者也有可能是兼容性考虑。

// 请将下面两条被注释掉的代码加，到你自己下载的一个google ig页面里面，把里面的所有其余删除，挂上这个js也可以拖拽了，哈哈
// _table=getElementById("t_1");
// = _IG_initDrag(_table);

使搜索引搜索蜘蛛的收录由被动变为主动，google Sitemap服务目前尚不提供在线创建Sitemap的功能，但是我们可以借助第三方网站提供的此类服务，打开网站（http://www.xml-sitemaps.com）（如图1） 

在“Starting URL”栏中输入你自己的网站地址，在“Change frequency”下拉列表选择网站的更新频率（经常 每天 每年等不同的时段），在“Last modification”选择最后修改时间（建议选择Use server's response服务器反映时间 ），在“Priority”栏中速入跟新的优先权，最后点击“Start”按钮创建网站地图 （如图0）

完成操作后，我们将在显示的结果中看到各式各样的网站生成地图Sitemap文件，将“Sitemap.xml”下载到本地然后再传到服务器主目录下，下面用Gmail帐户登陆到google Sitemap,添加自己的网站sitemap文件（如图2），再选在添加该站点的sitemap，注意在选择分类的时候选择添加常规网络(如图3)sitemap然后输入刚才上传得那个sitemap.xml地址，各式http://www.6b9g.com/sitemap.xml  再点击“添加普通sitemap” 按钮

首发 高峰 站长互动信息网   http://www.6b9g.com

Introducing FileUpload
The FileUpload component has the capability of simplifying the handling of files uploaded to a server. Note that the FileUpload component is meant for use on the server side; in other words, it handles where the files are being uploaded to—not the client side where the files are uploaded from. Uploading files from an HTML form is pretty simple; however, handling these files when they get to the server is not that simple. If you want to apply any rules and store these files based on those rules, things get more difficult.

The FileUpload component remedies this situation, and in very few lines of code you can easily manage the files uploaded and store them in appropriate locations. You will now see an example where you upload some files first using a standard HTML form and then using HttpClient code.

Using HTML File Upload
The commonly used methodology to upload files is to have an HTML form where you define the files you want to upload. A common example of this HTML interface is the Web page you encounter when you want to attach files to an email while using any of the popular Web mail services.

In this example, you will create a simple HTML page where you provide for three files to be uploaded. Listing 1-1 shows the HTML for this page. Note that the enctype attribute for the form has the multipart/form-data, and the input tag used is of type file. Based on the of the action attribute, on form submission, the data is sent to ProcessFileUpload.jsp.

Listing 1-1. UploadFiles.html
<HTML>
  <HEAD>
    < HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=windows-1252"/>
    <TITLE>File Upload Page</TITLE>
  </HEAD>
  <BODY>Upload Files
    <FORM name="filesForm" action="ProcessFileUpload.jsp"
    method="post" enctype="multipart/form-data">
        File 1:<input type="file" name="file1"/><br/>
        File 2:<input type="file" name="file2"/><br/>
        File 3:<input type="file" name="file3"/><br/>
        <input type="submit" name="Submit" ="Upload Files"/>
    </FORM>
  </BODY>
</HTML>

You can use a servlet to handle the file upload. I have used JSP to minimize the code you need to write. The task that the JSP has to accomplish is to pick up the files that are sent as part of the request and store these files on the server. In the JSP, instead of displaying the result of the upload in the Web browser, I have chosen to print messages on the server console so that you can use this same JSP when it is not invoked through an HTML form but by using HttpClient-based code.

Listing 1-2 shows the JSP code. Note the code that checks whether the item is a form field. This check is required because the Submit button contents are also sent as part of the request, and you want to distinguish between this data and the files that are part of the request. You have set the maximum file size to 1,000,000 bytes using the setSizeMax method.

Listing 1-2. ProcessFileUpload.jsp
<%@ page contentType="text/html;charset=windows-1252"%>
<%@ page import="org.apache.commons.fileupload.DiskFileUpload"%>
<%@ page import="org.apache.commons.fileupload.FileItem"%>
<%@ page import="jsp servlet ejb .util.List"%>
<%@ page import="jsp servlet ejb .util.Iterator"%>
<%@ page import="jsp servlet ejb .io.File"%>
html>
<head>
< http-equiv="Content-Type" content="text/html; charset=windows-1252">
<title>Process File Upload</title>
</head>
<%
        System.out.println("Content Type ="+request.getContentType());

        DiskFileUpload fu = new DiskFileUpload();
        // If file size exceeds, a FileUploadException will be thrown
        fu.setSizeMax(1000000);

        List fileItems = fu.parseRequest(request);
        Iterator itr = fileItems.iterator();

        while(itr.hasNext()) {
          FileItem fi = (FileItem)itr.next();

          //Check if not form field so as to only handle the file inputs
          //else condition handles the submit button input
          if(!fi.isFormField()) {
            System.out.println(""nNAME: "+fi.getName());
            System.out.println("SIZE: "+fi.getSize());
            //System.out.println(fi.getOutputStream().toString());
            File fNew= new File(application.getRealPath("/"), fi.getName());

            System.out.println(fNew.getAbsolutePath());
            fi.write(fNew);
          }
          else {
            System.out.println("Field ="+fi.getFieldName());
          }
        }
%>
<body>
Upload Successful!!
</body>
</html>

CAUTION With FileUpload 1.0 I found that when the form was submitted using Opera version 7.11, the getName method of the class FileItem returns just the name of the file. However, if the form is submitted using Internet Explorer 5.5, the filename along with its entire path is returned by the same method. This can cause some problems.

To run this example, you can use any three files, as the contents of the files are not important. Upon submitting the form using Opera and uploading three random XML files, the output I got on the Tomcat server console was as follows:

Content Type =multipart/form-data; boundary=----------rz7ZNYDVpN1To8L73sZ6OE

NAME: academy.xml
SIZE: 951
D:"javaGizmos"jakarta-tomcat-4.0.1"webapps"HttpServerSideApp"academy.xml

NAME: academyRules.xml
SIZE: 1211
D:"javaGizmos"jakarta-tomcat-4.0.1"webapps"HttpServerSideApp"academyRules.xml

NAME: students.xml
SIZE: 279
D:"javaGizmos"jakarta-tomcat-4.0.1"webapps"HttpServerSideApp"students.xml
Field =Submit
However, when submitting this same form using Internet Explorer 5.5, the output on the server console was as follows:
Content Type =multipart/form-data; boundary=---------------------------7d3bb1de0
2e4

NAME: D:"temp"academy.xml
SIZE: 951
D:"javaGizmos"jakarta-tomcat-4.0.1"webapps"HttpServerSideApp"D:"temp"academy.xml

The browser displayed the following message: “The requested resource (D:"javaGizmos"jakarta-tomcat-4.0.1"webapps"HttpServerSideApp"D:"temp"academy.xml (The filename, directory name, or volume label syntax is incorrect)) is not available.”

This contrasting behavior on different browsers can cause problems. One workaround that I found in an article at http://www.onjava.com/pub/a/onjava/2003/06/25/commons.html is to first create a file reference with whatever is supplied by the getName method and then create a new file reference using the name returned by the earlier file reference. Therefore, you can insert the following code to have your code work with both browsers (I wonder who the guilty party is…blaming Microsoft is always the easy way out)

File tempFileRef  = new File(fi.getName());
File fNew = new File(application.getRealPath("/"),tempFileRef.getName());

In this section, you uploaded files using a standard HTML form mechanism. However, often a need arises to be able to upload files from within your jsp servlet ejb code, without any browser or form coming into the picture. In the next section, you will look at HttpClient-based file upload.

Using HttpClient-Based FileUpload
Earlier in the article you saw some of the capabilities of the HttpClient component. One capability I did not cover was its ability to send multipart requests. In this section, you will use this capability to upload a few files to the same JSP that you used for uploads using HTML.

The class org.apache.commons.httpclient.methods.MultipartPostMethod provides the multipart method capability to send multipart-encoded forms, and the package org.apache.commons.httpclient.methods.multipart has the support classes required. Sending a multipart form using HttpClient is quite simple. In the code in Listing 1-3, you send three files to ProcessFileUpload.jsp.

Listing 1-3. HttpMultiPartFileUpload.java
package com.commonsbook.chap9;
import jsp servlet ejb .io.File;
import jsp servlet ejb .io.IOException;

import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.methods.MultipartPostMethod;

public class HttpMultiPartFileUpload {
    private static String url =
      "http://localhost/yaoliang/ProcessFileUpload.jsp";

    public static void main(String[] args) throws IOException {
        HttpClient client = new HttpClient();
        MultipartPostMethod mPost = new MultipartPostMethod(url);
        client.setConnectionTimeout(8000);

        // Send any XML file as the body of the POST request
        File f1 = new File("D:/students.xml");
        File f2 = new File("D:/demy.xml");
        File f3 = new File("D:/demyRules.xml");

        System.out.println("File1 Length = " + f1.length());
        System.out.println("File2 Length = " + f2.length());
        System.out.println("File3 Length = " + f3.length());

        mPost.addParameter(f1.getName(),f1.getName(),  f1);
        mPost.addParameter(f2.getName(), f2.getName(), f2);
        mPost.addParameter(f3.getName(), f3.getName(),f3);

FilePart part1 = new FilePart("file1",file);
FilePart part2 = new FilePart("file2",file);
FilePart part3 = new FilePart("file3",file);
mPost.addPart(part1);
mPost.addPart(part2);
mPost.addPart(part3);

        int statusCode1 = client.executeMethod(mPost);

        System.out.println("statusLine>>>" + mPost.getStatusLine());
        mPost.releaseConnection();
    }
}

In this code, you just add the files as parameters and execute the method. The ProcessFileUpload.jsp file gets invoked, and the output is as follows:

Content Type =multipart/form-data; boundary=----------------31415926535897932384
6

NAME: students.xml
SIZE: 279
D:"javaGizmos"jakarta-tomcat-4.0.1"webapps"HttpServerSideApp"students.xml

NAME: academy.xml
SIZE: 951
D:"javaGizmos"jakarta-tomcat-4.0.1"webapps"HttpServerSideApp"academy.xml

NAME: academyRules.xml
SIZE: 1211
D:"javaGizmos"jakarta-tomcat-4.0.1"webapps"HttpServerSideApp"academyRules.xml

Thus, file uploads on the server side become quite a simple task if you are using the Commons FileUpload component.

我们不可能列举所 有可能的顽固，我们会针对几种最常见的问题进行处理。当然了，正如前面说到的，如果我们自己使用java.net.HttpURLConnection来 搞定这些问题是很恐怖的事情，因此在开始之前我们先要介绍一下一个开放源码的项目，这个项目就是Apache开源组织中的httpclient，它隶属于 Jakarta的commons项目，目前的版本是2.0RC2。commons下本来已经有一个net的子项目，但是又把httpclient单独提出 来，可见http服务器的访问绝非易事。

Commons-httpclient 项目就是专门设计来简化HTTP客户端与服务器进行各种通讯编程。通过它可以让原来很头疼的事情现在轻松的解决，例如你不再管是HTTP或者HTTPS的 通讯方式，告诉它你想使用HTTPS方式，剩下的事情交给httpclient替你完成。本文会针对我们在编写HTTP客户端程序时经常碰到的几个问题进 行分别介绍如何使用httpclient来解决它们，为了让读者更快的熟悉这个项目我们最开始先给出一个简单的例子来读取一个网页的内容，然后循序渐进解 决掉前进中的所有问题。

1． 读取网页(HTTP/HTTPS)内容

下面是我们给出的一个简单的例子用来访问某个页面

/*

* Created on 2003-12-14 by Liudong

*/

package http.demo;

import java.io.IOException;

import org.apache.commons.httpclient.*;

import org.apache.commons.httpclient.methods.*;

/**

* 最简单的HTTP客户端,用来演示通过GET或者POST方式访问某个页面

* @author Liudong

*/

public class SimpleClient {

    public static void main(String[] args) throws IOException

    {

        HttpClient client = new HttpClient();    

        //设置代理服务器地址和端口    

        //client.getHostConfiguration().setProxy("proxy_host_addr",proxy_port);

        //使用GET方法，如果服务器需要通过HTTPS连接，那只需要将下面URL中的http换成https

        HttpMethod method = new GetMethod("http://java.sun.com");

        //使用POST方法

        //HttpMethod method = new PostMethod("http://java.sun.com");

        client.executeMethod(method);

        //打印服务器返回的状态

        System.out.println(method.getStatusLine());

        //打印返回的信息

        System.out.println(method.getResponseBodyAsString());

        //释放连接

        method.releaseConnection();

    }
}

在这个例子中首先创建一个 HTTP客户端(HttpClient)的实例，然后选择提交的方法是GET或者POST，最后在HttpClient实例上执行提交的方法，最后从所选 择的提交方法中读取服务器反馈回来的结果。这就是使用HttpClient的基本流程。其实用一行代码也就可以搞定整个请求的过程，非常的简单！

import java.security.*;

import java.io.*;

import java.util.*;

import java.security.*;

import java.security.cert.*;

import sun.security.x509.*

import java.security.cert.Certificate;

import java.security.cert.CertificateFactory;

二 从文件中读取证书

用keytool将.keystore中的证书写入文件中，然后从该文件中读取证书信息

CertificateFactory cf=CertificateFactory.getInstance("X.509");

FileInputStream in=new FileInputStream("out.csr");

Certificate c=cf.generateCertificate(in); String s=c.toString();

三 从密钥库中直接读取证书

String pass="123456";

FileInputStream in=new FileInputStream(".keystore");

KeyStore ks=KeyStore.getInstance("JKS");

ks.load(in,pass.toCharArray());

java.security.cert.Certificate c=ks.getCertificate(alias);//alias为条目的别名

四 JAVA程序中显示证书指定信息

System.out.println("输出证书信息:"n"+c.toString());

System.out.println("版本号:"+t.getVersion());

System.out.println("序列号:"+t.getSerialNumber().toString(16));

System.out.println("主体名："+t.getSubjectDN());

System.out.println("签发者："+t.getIssuerDN());

System.out.println("有效期："+t.getNotBefore());

System.out.println("签名算法："+t.getSigAlgName());

byte [] sig=t.getSignature();//签名值

PublicKey pk=t.getPublicKey();

byte [] pkenc=pk.getEncoded();

System.out.println("公钥");

for(int i=0;i<pkenc.length;i++)System.out.print(pkenc[i]+",");

五 JAVA程序列出密钥库所有条目

String pass="123456";

FileInputStream in=new FileInputStream(".keystore");

KeyStore ks=KeyStore.getInstance("JKS");

ks.load(in,pass.toCharArray());

Enumeration e=ks.aliases();

while(e.hasMoreElements())

java.security.cert.Certificate c=ks.getCertificate((String)e.nextElement());

六 JAVA程序修改密钥库口令

String oldpass="123456";

String newpass="654321";

FileInputStream in=new FileInputStream(".keystore");

KeyStore ks=KeyStore.getInstance("JKS");

ks.load(in,oldpass.toCharArray());

in.close();

FileOutputStream output=new FileOutputStream(".keystore");

ks.store(output,newpass.toCharArray());

output.close();

七 JAVA程序修改密钥库条目的口令及添加条目

FileInputStream in=new FileInputStream(".keystore");

KeyStore ks=KeyStore.getInstance("JKS");

ks.load(in,storepass.toCharArray());

Certificate [] cchain=ks.getCertificate(alias);获取别名对应条目的证书链

PrivateKey pk=(PrivateKey)ks.getKey(alias,oldkeypass.toCharArray());获取别名对应条目的私钥

ks.setKeyEntry(alias,pk,newkeypass.toCharArray(),cchain);向密钥库中添加条目

第一个参数指定所添加条目的别名，假如使用已存在别名将覆盖已存在条目，使用新别名将增加一个新条目，第二个参数为条目的私钥，第三个为设置的新口令，第四个为该私钥的公钥的证书链

FileOutputStream output=new FileOutputStream("another");

ks.store(output,storepass.toCharArray())将keystore对象内容写入新文件

八 JAVA程序检验别名和删除条目

FileInputStream in=new FileInputStream(".keystore");

KeyStore ks=KeyStore.getInstance("JKS");

ks.load(in,storepass.toCharArray());

ks.containsAlias("sage");检验条目是否在密钥库中，存在返回true

ks.deleteEntry("sage");删除别名对应的条目

FileOutputStream output=new FileOutputStream(".keystore");

ks.store(output,storepass.toCharArray())将keystore对象内容写入文件,条目删除成功

九 JAVA程序签发数字证书

（1）从密钥库中读取CA的证书

FileInputStream in=new FileInputStream(".keystore");

KeyStore ks=KeyStore.getInstance("JKS");

ks.load(in,storepass.toCharArray());

java.security.cert.Certificate c1=ks.getCertificate("caroot");

（2）从密钥库中读取CA的私钥

PrivateKey caprk=(PrivateKey)ks.getKey(alias,cakeypass.toCharArray());

（3）从CA的证书中提取签发者的信息

byte[] encod1=c1.getEncoded(); 提取CA证书的编码

X509CertImpl cimp1=new X509CertImpl(encod1); 用该编码创建X509CertImpl类型对象

X509CertInfo cinfo1=(X509CertInfo)cimp1.get(X509CertImpl.NAME+"."+X509CertImpl.INFO); 获取X509CertInfo对象

X500Name issuer=(X500Name)cinfo1.get(X509CertInfo.SUBJECT+"."+CertificateIssuerName.DN_NAME); 获取X509Name类型的签发者信息

（4）获取待签发的证书

CertificateFactory cf=CertificateFactory.getInstance("X.509");

FileInputStream in2=new FileInputStream("user.csr");

java.security.cert.Certificate c2=cf.generateCertificate(in);

（5）从待签发的证书中提取证书信息

byte [] encod2=c2.getEncoded();

X509CertImpl cimp2=new X509CertImpl(encod2); 用该编码创建X509CertImpl类型对象

X509CertInfo cinfo2=(X509CertInfo)cimp2.get(X509CertImpl.NAME+"."+X509CertImpl.INFO); 获取X509CertInfo对象

（6）设置新证书有效期

Date begindate=new Date(); 获取当前时间

Date enddate=new Date(begindate.getTime()+3000*24*60*60*1000L); 有效期为3000天

CertificateValidity cv=new CertificateValidity(begindate,enddate); 创建对象

cinfo2.set(X509CertInfo.VALIDITY,cv); 设置有效期

（7）设置新证书序列号

int sn=(int)(begindate.getTime()/1000); 以当前时间为序列号

CertificateSerialNumber csn=new CertificateSerialNumber(sn);

cinfo2.set(X509CertInfo.SERIAL_NUMBER,csn);

（8）设置新证书签发者

cinfo2.set(X509CertInfo.ISSUER+"."+CertificateIssuerName.DN_NAME,issuer);应用第三步的结果

（9）设置新证书签名算法信息

AlgorithmId algorithm=new AlgorithmId(AlgorithmId.md5WithRSAEncryption_oid);

cinfo2.set(CertificateAlgorithmId.NAME+"."+CertificateAlgorithmId.ALGORITHM,algorithm);

（10）创建证书并使用CA的私钥对其签名

X509CertImpl newcert=new X509CertImpl(cinfo2);

newcert.sign(caprk,"MD5WithRSA"); 使用CA私钥对其签名

（11）将新证书写入密钥库

ks.setCertificateEntry("lf_signed",newcert);

FileOutputStream out=new FileOutputStream("newstore");

ks.store(out,"newpass".toCharArray()); 这里是写入了新的密钥库，也可以使用第七条来增加条目

十 数字证书的检验

（1）验证证书的有效期

（a）获取X509Certificate类型对象

CertificateFactory cf=CertificateFactory.getInstance("X.509");

FileInputStream in1=new FileInputStream("aa.crt");

java.security.cert.Certificate c1=cf.generateCertificate(in1);

X509Certificate t=(X509Certificate)c1;

in2.close();

（b）获取日期

Date TimeNow=new Date();

（c）检验有效性

try{

t.checkValidity(TimeNow);

System.out.println("OK");

}catch(CertificateExpiredException e){ //过期

System.out.println("Expired");

System.out.println(e.getMessage());

}catch((CertificateNotYetValidException e){ //尚未生效

System.out.println("Too early");

System.out.println(e.getMessage());}

（2）验证证书签名的有效性

（a）获取CA证书

CertificateFactory cf=CertificateFactory.getInstance("X.509");

FileInputStream in2=new FileInputStream("caroot.crt");

java.security.cert.Certificate cac=cf.generateCertificate(in2);

in2.close();

（c）获取CA的公钥

PublicKey pbk=cac.getPublicKey();

（b）获取待检验的证书（上步已经获取了，就是C1）

（c）检验证书

boolean pass=false;

try{

c1.verify(pbk);

pass=true;

}catch(Exception e){

pass=false;

System.out.println(e);

}

    使用BC Provider在Java中构造一个证书请求格式的对象调用其构造函数即可,这个函数如下:

    PKCS10CertificationRequest(java.lang.String signatureAlgorithm, X509Name subject, java.security.PublicKey key, ASN1Set attributes, java.security.PrivateKey signingKey)

    它的参数是自签名算法,证书申请者的DN,证书申请者的公钥,额外的属性集(就是要申请的证书的扩展信息),申请证书者的私钥.申请证书者的私钥仅仅是用来进行一下自签名,并不出现在证书请求中,需要自签名的目的是保证该公钥确实为申请者所有.

    调用该对象的getEncoded()方法可以将其进行DER编码,然后储存起来,该对象还有另一个构造函数:
    PKCS10CertificationRequest(byte[] bytes)
    这个构造函数的作用就是直接从储存的DER编码中把这个对象还原出来.

    利用证书请求结构进行证书签发的代码如下,这里假设CSR是一个已经获取出来的PKCS10CertificationRequest结构:

    PublicKey SubjectPublicKey = CSR.getPublicKey();
    CertificationRequestInfo CSRInfo = CSR.getCertificationRequestInfo();
    X509Name SubjectDN = CSRInfo.getSubject();
    ASN1Set Attributes = CSRInfo.getAttributes();

    这样,申请者的主体DN,申请者的公钥,申请者希望在证书扩展信息中填写的属性都得到了,剩下的事情就和用户在现场输入时一样了,其它的信息一般是申请者 不能决定的.另外证书请求格式中有一样信息没有明确给出来,那就是证书的有效期,这个应该单独询问用户,或者用其它的方法保存起来.

    一个TBS中包含了以下这些主要信息:

    证书的版本,通常是3(X509v3)

    证书的序列号,RFC3280中规定,每个CA必须确保它颁发的每一份证书的序列号都是唯一的,并且序列号只能使用非负整数.

    签发者(CA)的主体名称,一个DN对象.

    证书的有效期,表示方法是两个时间值,表示了该证书从何时开始生效,何时开始作废.

    待认证的主体的主体名称,也是一个DN对象.

    待认证的主体的公钥,任何安全应用在确认完证书的有效性后,就可以开始使用该主体的公钥与之进行安全通信.

    如果是X509v3证书,即版本号是3的话,后面还有一个证书扩展信息字段,可以在证书里面添加一些其它的信息.

    下面我们来看一下表示主体的主体名称结构:DN.这个结就构是一个属性的集合.每个属性有属性名称和属性值.它的作用就是用来表示"我是谁",也就是说,这个证书到底是谁颁发给谁的,这个证书对应的公钥是谁拥有的.

    通常使用一个字符串来表示DN结构,这种字符串说明了这种结构中的各个属性的类型和值:

    C=CN;S=BeiJing;L=BeiJing;O=PKU;OU=ICST;CN=wolfenstein

    这里C是国家和地区代码,S和L都是地区代码,S相当于省或者州这样的级别,L相当于城市级别,O是组织机构名称,OU是次级组织机构名称,CN是主体的 通用名(common name).在这里,C,S,L等等属性的类型都是相对固定的,例如C一般就是用来表示国家和地区代码,在DN结构中还可以添加一些其它类型的信息,一般 也都是以"xxx=xxx"这样来表示的.

    下面我们来说明如何在Java语言中构造出一个主体名称对象.

    BC Provider中使用X509Name对象来表示DN,构造一个X509Name的步骤大体如下:

    先构造两个vector对象,用来表示属性名称和属性值:

    Vector oids = new Vector();
    Vector attributes = new Vector();

    然后在oids这个用来表示属性名称的vector对象中将属性名称一个一个添加进去:

    oids.addElement(X509Name.C);

    ......

    oids.addElement(X509Name.CN);

    X509Name对象里面有若干常量,例如上面的X509Name.C.还有X509Name.ST等等,都可以和上面举的例子对应起来.

    然后将属性值添加到attributes对象中:

    attributes.addElement("CN");

    ......

    attributes.addElement("Wolfenstein");

    最后就可以构造出一个X509Name对象:

    X509Name SubjectDN = new X509Name(oids, attributes);

    这样,我们的主体名称结构就确立起来了.

    下次我们就可以讲关键的部分了,那就是如何用Java程序完成CA最重要的功能,签署证书.

    然后我们就可以开始开CA了.首先,作为一个CA要有自己的一对公钥和私钥,我们先要生成这么一对.使用KeyPairGenerator对象就可以了, 调用KeyPairGenerator.getInstance方法可以根据要生成的密钥类型来产生一个合适的实例,例如常用的RSA,DSA等.然后调 用该对象的initialize方法和generateKeyPair方法就可以产生一个KeyPair对象了.然后调用KeyPair对象中的相应方法 就可以获取生成的密钥对中的公钥和私钥了.

    有了公钥和私钥对以后,下面的一个很现实问题就是如何把它们储存起来.通常我们要对这些安全对象,如公钥,私钥,证书等先进行编码.编码的目的是为了把结 构复杂的安全对象变成字节流以便存储和读取,如DER编码.另外,通常还把DER编码后的字节流再次进行base64编码,以便使字节流中所有的字节都变 成可打印的字节.

    在Java语言中,这些安全对象基本上都有getEncoded()方法.例如:

    byte[] keyBytes = privateKey.getEncoded();

    这样就把一个私钥进行了DER编码后的结果保存到一个byte数组中了.然后就可以把这个byte数组保存到任何介质中.如果有必要的话,可以使用BC Provider中的Base64编码解码器类进行编码,就像这样:

    byte data[] = Base64.encode(keyBytes);

    要从文件中读取私钥则应该这样:

    PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(keyData);
    KeyFactory kfac = KeyFactory.getInstance("RSA");
    privateKey = kfac.generatePrivate(spec);

    这里说明一下,对RSA私钥进行编码就会自动地按照PKCS8进行.因此读取的时候将包含编码的字节数组作为PKCS8EncodedKeySpec对象 的构造函数的参数就可以生成一个该类型的对象.然后创建一个密钥工厂对象就可以按照要求生成一个RSA私钥了.很显然这里的keyData应该是和上面的 keyBytes内容相同.

    为了提高系统的安全性,通常私钥在经过DER编码后,还会使用一个口令进行加密,然后再储存在文件系统中.在使用私钥的时候,如果没有正确的口令,是无法把私钥还原出来的.

    保存证书和保存私钥类似.Certificate对象中也有一个getEncoded的方法.

    这次先写这么多了,下次开始具体讲把这些东西搞下来后怎么开始干活吧.我以我现在手头上正在做的事情告诉大家,如何做一个CA.

    有了BC Provider,开CA,真的就是这么简单!

    服务端应用‘服务端私钥’和‘客户端公钥’与客户端通讯；客户端应用‘客户端私钥’和‘服务端公钥’与服务端通讯。

　如下介绍证书生成（一套）：

　１、用JDK的keytool生成密钥store

    keytool -genkey -alias mykey -keystore srvstore

    输入密码（程序中密码为‘123456’）和相应的证书信息

    ２、从srvstore中导出证书

    keytool -export -alias mykey -file srvcert.crt -keystore srvstore

    输入刚才上面设置的密码

    ３、将证书导到公钥中

     keytool -import -alias mytrust -file srvcert.crt -keystore srvtrust

     输入公钥的密码（程序中密码为‘123456’）

• att:Tomcat5SSL_ServerAndClient 在 Tomcat 5.5 上的配置实例.tomcat5.5-ssl-sample.zip

第一步: 将服务器端证书 ssl-test.net-tomcat.keystore 复制到 Tomcat 的 conf 目录中

第二步: 修改 Tomcat 的 conf 目录下 server.xml 文件, 加上 SSL Connector 的定义

• 注意: 如果需要使用双向 SSL(即客户端也要求使用证书), 那么必须设置 clientAuth="true";
• 
• 顺便把 HTTP Connector 的 URLEncoding 也设置成 UTF-8, 这个主要是为了解决一些中文问题(与本试验无关, 你也可以不配置):
• 

第三步: 在 Tomcat 的 webapps 目录下建立一个新的 Web 应用 "ssltest", 编辑 ssltest 目录下 WEB-INF/web.xml, 配置 ssltest/ssl/ 目录下的内容为必须通过 SSL 方式才能访问

第四步: 写两个完全一样的测试页面, 分别放在 ssltest/ 和 ssltest/ssl/ 目录下, 按照上一步的配置, ssltest/ssl/ 目录下的测试页面必须通过 SSL 方式才能访问

第五步: 导入客户端证书到浏览器中(双击客户端证书文件 "web-client.p12" 即可导入 IE)

实际运行效果

相关下载

• att:Tomcat5SSL_ServerAndClient 在 Tomcat 5.5 上的配置实例.tomcat5.5-ssl-sample.zip

• 生成的CA私钥(ca-key.pem)以及自签名根证书(ca-cert.pem)均为没有加密的明文, 由于一旦在服务器发布, 以及客户端证书发布之后, 根证书是不能随便修改的, 那么在保管没有加密的CA私钥以及自签名根证书时就会存在安全性问题(如果别人得到你的CA根证书, 他就可以替你生成客户端证书了);
• 生成的服务器端证书(server_keystore)不包括信任的CA根证书, 信任的CA根证书被导入到JSSE的默认位置, 如果进行证书操作的计算机和真正运行Web应用的不是同一台计算机, 那么在安装服务器端证书的时候, 还需要在服务器上将CA根证书导入JSSE默认位置;
• 生成客户端证书的过程比较烦琐, 不方便批量进行客户端证书的生成;
• 没有统一的配置文件, 生成证书的过程中需要执行相当多的命令, 可重复性差, 出错的可能性比较大.

用到的软件包

• Tomcat 5.0.x
• JSSE 中的 keytool 工具, 在 JDK 1.4 中已经自带了这个工具, 因此, 只需要安装 JDK1.4.x 即可
• openssl(openssl 已经被包含在这个工具包里面了, 不需要另外安装, 参见工具包下载)
• cygwin 的 sed 和 echo 命令(这些命令文件已经包含在工具包里面, 不需要另外安装, 参见工具包下载)

配置及主要命令介绍

• PATH 环境变量
  • 安装 JDK 之后, 需要将环境变量 JAVA_HOME 设置为 JDK 的安装目录, 同时在 PATH 中加上 %JAVA_HOME%"bin.
• 工具包结构
  • .bin: 存放openssl 以及 cygwin 的 sed 和 echo 命令的可执行执行文件;
  • .etc: 存放系统的配置文件, 其中最主要的配置文件是 .etc/config.cmd;
  • dist: 这个目录存放产生的各种证书;
  • work: 产生证书时使用的临时文件的存放目录, 为了安全起见, 在每次证书相关操作结束后, 建议清空这个目录;
  • step0,1,2,3 四个批处理命令: 这四个命令分别用于证书各个方面的操作.
• .etc/config.cmd
  • 这个文件是系统的配置文件, 主要配置 CA根证书/服务器证书/客户端证书 的相关信息, 例如证书的distinguished name信息等等, 在生成证书之前, 需要首先根据实际情况更新这个配置文件;
• step0-ca-pfx.bat
  • 该命令生成CA私钥以及自签名根证书, 最后得到PKCS12格式的CA根证书(PKCS12格式的CA根证书受密码保护, 因此有比较好的安全性);
  • 生成的PKCS12格式的CA根证书保存在 dist"ca-cert 目录下, 在正式使用的系统中, 这个证书文件(*.pfx)需要妥善保存, 因为以后的服务器证书和客户端证书都需要依赖这个证书, 尤其是客户端证书, 如果丢失了CA根证书, 就无法发布新的客户端证书了, 而重新生成CA根证书, 则需要重新生成服务器证书和客户端证书, 在客户端用户较多的情况下, 重新发布所有的客户端证书是有相当大的工作量;
  • 在执行这个命令的过程中, 会提示输入证书保护密码, 请注意不要遗忘或者泄漏这个密码, 否则根证书的安全会受到威胁.
• step1-ca-prepare.bat
  • 该命令用于从PKCS12格式的CA根证书中导出CA私钥和未加密CA根证书;
  • 由于安全原因, CA根证书平时以密码保护的PKCS12格式文件(*.pfx)存放, 那么如果需要使用CA根证书来发布服务器证书或者客户端证书时, 首先需要执行这个命令得到CA根证书的未加密形式;
  • 在执行这个命令的过程中, 会出现两次提示输入根证书的保护密码, 如果密码不正确, 这个命令将不能执行成功, 也就无法进行下面两步的发布证书的操作了.
• step2-server.bat
  • 该命令用于生成服务器端证书(keystore文件);
  • 注意: CA根证书同时也会被导入到证书的keystore文件中, 这样在将这个证书应用到Tomcat Web服务器上的时候就不需要将CA根证书导入到JSSE的默认位置了;
  • 这个命令必须在执行 step1-ca-prepare.bat 之后才能正常运行.
• step3-client.bat
  • 这个命令用于发布客户端证书;
  • 为了便于批量生成客户端证书, 这个命令支持命令行参数, 第1到3个参数依次为:
    • 客户端证书的名称(Common Name)
    • 客户端证书所属的组织(Organizational Unit Name)
    • 产生的PKS12格式客户端证书的导入密码, 这个密码可以保护证书只能被知道密码的用户导入到浏览器
  • 这个命令必须在执行 step1-ca-prepare.bat 之后才能正常运行.

Tomcat 5 服务器配置

• 将 "step2-server.bat" 命令产生的 dist"server 目录下的 keystore 文件(如果使用本工具包的默认配置, 这个文件叫做"ssl-test.net-tomcat.keystore")复制到 Tomcat 安装目录的 conf 目录下;
• 修改 Tomcat 安装目录的 conf 目录下的 "server.xml" 文件, 修改 <Service name="Catalina"> 包含的 "Connector" 元素, 示例如下(仅供参考):

  <Service name="Catalina">

<Connector URIEncoding="UTF-8"

acceptCount="100" connectionTimeout="20000" disableUploadTimeout="true"

port="8080" redirectPort="8443"

maxSpareThreads="75" maxThreads="150" minSpareThreads="25">

</Connector>

<Connector URIEncoding="UTF-8" port="8443"

maxThreads="150" minSpareThreads="25" maxSpareThreads="75"

enableLookups="false" disableUploadTimeout="true"

acceptCount="100" debug="0" scheme="https" secure="true"

clientAuth="true" sslProtocol="TLS"

keystoreFile="${catalina.home}/conf/ssl-test.net-tomcat.keystore"

keystorePass="openssl"

truststoreFile="${catalina.home}/conf/ssl-test.net-tomcat.keystore"

truststorePass="openssl"/>

......

启用双向 SSL 时 Web 应用程序的配置

• 要启用双向 SSL 认证, 在 Web 应用程序的 web.xml 中需要如下增加一些配置: auth-method=CLIENT-CERT 说明是"以客户端数字证书来确认用户的身份", transport-guarantee=CONFIDENTIAL 表示应用程序要求数据必须在一种"防止其他实体看到传输的内容的方式中传送".

    <login-config>

<!-- Authorization setting for SSL -->

<auth-method>CLIENT-CERT</auth-method>

<realm-name>Client Cert Users-only Area</realm-name>

</login-config>

<security-constraint>

<!-- Authorization setting for SSL -->

<web-resource-collection >

<web-resource-name >SSL</web-resource-name>

<url-pattern>/*</url-pattern>

</web-resource-collection>

<user-data-constraint>

<transport-guarantee>CONFIDENTIAL</transport-guarantee>

</user-data-constraint>

</security-constraint>

• 经过以上的配置之后, 那么即使用户是通过 http 访问 Web 应用程序的, 浏览器也会自动切换到 https 方式并弹出选择客户端证书的对话框.

如何使用客户端证书进行用户验证

• 查看一些资料上提到客户端证书内容中 subject 的 CN 部分可以和 Tomcat 的 Realm 中的用户集成, 不过一直没有尝试成功;
• 在 web 应用程序中, 可以通过 java 代码从 request 对象中获得, 根据 Servlet Specifications, 使用request.getAttribute("javax.servlet.request.X509Certificate") 就可以得到 https 请求的客户端证书链信息, 其中第一个元素就是客户端证书, 相应的示例代码如下:

1．Tomcat简介
Tomcat 是Apache Jakarta的子项目之一，作为一个优秀的开源web应用服务器，全面支持jsp1.2以及servlet2.3规范。因其技术先进、性能稳定，而且免 费，因而深受Java爱好者的喜爱并得到了部分软件开发商的认可，成为目前比较流行的web应用服务器。

2．SSL(Server Socket Layer)简介
在 网络上信息在源-宿的传递过程中会经过其它的计算机。一般情况下，中间的计算机不会监听路过的信息。但在使用网上银行或者进行信用卡交易的时候有可能被监 视，从而导致个人隐私的泄露。由于Internet和Intranet体系结构的原因，总有某些人能够读取并替换用户发出的信息。随着网上支付的不断发 展，人们对信息安全的要求越来越高。因此Netscape公司提出了SSL协议，旨在达到在开放网络(Internet)上安全保密地传输信息的目的，这 种协议在WEB上获得了广泛的应用。之后IETF(www.ietf.org)对SSL作了标准化，即RFC2246，并将其称为TLS （Transport Layer Security），从技术上讲，TLS1.0与SSL3.0的差别非常微小。

3．SSL工作原理
SSL协议使用不对称加密技术实现会话双方之间信息的安全传递。可以实现信息传递的保密性、完整性，并且会话双方能鉴别对方身份。不同于常用的http协议，我们在与网站建立SSL安全连接时使用https协议，即采用https://ip:port/的方式来访问。

当我们与一个网站建立https连接时，我们的浏览器与Web Server之间要经过一个握手的过程来完成身份鉴定与密钥交换，从而建立安全连接。具体过程如下：

1. 用户浏览器将其SSL版本号、加密设置参数、与session有关的数据以及其它一些必要信息发送到服务器。
2. 服务器将其SSL版本号、加密设置参数、与session有关的数据以及其它一些必要信息发送给浏览器，同时发给浏览器的还有服务器的证书。如果配置服务器的SSL需要验证用户身份，还要发出请求要求浏览器提供用户证书。
3. 客户端检查服务器证书，如果检查失败，提示不能建立SSL连接。如果成功，那么继续。
4. 客户端浏览器为本次会话生成pre-master secret，并将其用服务器公钥加密后发送给服务器。
5. 如果服务器要求鉴别客户身份，客户端还要再对另外一些数据签名后并将其与客户端证书一起发送给服务器。
6. 如果服务器要求鉴别客户身份，则检查签署客户证书的CA是否可信。如果不在信任列表中，结束本次会话。如果检查通过，服务器用自己的私钥解密收到的pre-master secret，并用它通过某些算法生成本次会话的master secret。
7. 客户端与服务器均使用此master secret生成本次会话的会话密钥(对称密钥)。在双方SSL握手结束后传递任何消息均使用此会话密钥。这样做的主要原因是对称加密比非对称加密的运算量低一个数量级以上，能够显著提高双方会话时的运算速度。
8. 客户端通知服务器此后发送的消息都使用这个会话密钥进行加密。并通知服务器客户端已经完成本次SSL握手。
9. 服务器通知客户端此后发送的消息都使用这个会话密钥进行加密。并通知客户端服务器已经完成本次SSL握手。
10. 本次握手过程结束，会话已经建立。双方使用同一个会话密钥分别对发送以及接受的信息进行加、解密。

4．配置Tomcat 4.x 使用SSL

4.1 用到的软件包

• Tomcat 4.0.2
  用途：Web Server。
  下载：http://jakarta.apache.org/builds/jakarta-tomcat-4.0/release/v4.0.3/bin/
• JSSE 1.0,2
  用途：用来产生Tocmcat使用的秘钥对(keystore)。
  下载： http://java.sun.com/products/jsse/
• Openssl 0.9.9.6
  用途：用来产生CA证书、签名并生成IE可导入的PKCS#12格式私钥。
  下载：http://www.openssl.org/

以上工具的安装过程可以参考自带的帮助，本文就不再详细描述了。

4.2 建立自己的CA

4.2.1 建立工作目录
mkdir ca

4.2.2 生成CA私钥以及自签名根证书
4.2.2.1 生成CA私钥
openssl genrsa -out ca"ca-key.pem 1024

4.2.2.2 生成待签名证书
openssl req -new -out ca"ca-req.csr -key ca"ca-key.pem

4.2.2.3 用CA私钥进行自签名
openssl x509 -req -in ca"ca-req.csr -out ca"ca-cert.pem -signkey ca"ca-key.pem -days 365

4.3 设置Tomcat 4.x
在本文中用符号"%JDK_HOME%"来表示JDK的安装位置，用符号"%TCAT_HOME%" 表示Tomcat的安装位置。

4.3.1建立工作目录
mkdir server

4.3.2 生成server端证书
4.3.2.1 生成KeyPair
%JDK_HOME%"bin"keytool -genkey -alias tomcat_server -validity 365 -keyalg RSA -keysize 1024 -keypass changeit -storepass changeit -dname "cn=localhost, ou=department, o=company, l=Beijing, st=Beijing, c=CN" -keystore server"server_keystore

4.3.2.2 生成待签名证书
%JDK_HOME%"bin"keytool -certreq -alias tomcat_server -sigalg MD5withRSA -file server"server.csr -keypass changeit -keystore server"server_keystore -storepass changeit

4.3.2.3 用CA私钥进行签名
openssl x509 -req -in server"server.csr -out server"server-cert.pem -CA ca"ca-cert.pem -CAkey ca"ca-key.pem -days 365

4.3.2.4 导入信任的CA根证书到JSSE的默认位置(%JDK_ROOT %/jre/security/cacerts)
%JDK_HOME%"bin"keytool -import -v -trustcacerts -storepass changeit -alias my_ca_root -file ca"ca-cert.pem -keystore %JDK_HOME%"jre"lib"security"cacerts

4.3.2.5 把CA签名后的server端证书导入keystore
%JDK_HOME%"bin"keytool -import -v -trustcacerts -storepass changeit -alias tomcat_server -file server"server-cert.pem -keystore server"server_keystore

4.3.2.6 查看server端证书
keytool -list -keystore %JDK_HOME%"jre"lib"security"cacerts
keytool -list -keystore server"server_keystore

4.3.3 修改server.xml使Tomcat支持SSL
首先找到以下内容，去掉对其的注释。然后参照红色部分修改。如果配置Tomcat不验证客户身份，可以设置clientAuth="false"。

<Connector className="org.apache.catalina.connector.http.HttpConnector" port="8443" minProcessors="5" maxProcessors="75" enableLookups="true" acceptCount="10" debug="0" scheme="https" secure="true"> <Factory className="org.apache.catalina.net.SSLServerSocketFactory" clientAuth="true" protocol="TLS" keystoreFile="%TCAT_HOME%/conf/server_keystore" keystorePass="changeit" /> </Connector>

然后把文件server"server_keystore复制到目录%TCAT_HOME%"conf"下。

4.4 在IE中安装个人证书
4.4.1 建立工作目录
mkdir client

4.4.2 生成client私钥并用CA私钥签名

4.4.2.1 生成client私钥
openssl genrsa -out client"client-key.pem 1024

4.4.2.2 生成待签名证书
openssl req -new -out client"client-req.csr -key client"client-key.pem

4.4.2.3 用CA私钥进行签名
openssl x509 -req -in client"client-req.csr -out client"client.crt -signkey client"client-key.pem -CA ca"ca-cert.pem -CAkey ca"ca-key.pem -CAcreateserial -days 365

4.4.2.4 生成client端的个人证书
因为JSSE1.0.2没有完全实现了对PKCS#12格式文件的操作(只能读取，不能输出)，所以在这里需要用openssl制作client端的个人证书(包含私钥)。
openssl pkcs12 -export -clcerts -in client"client.crt -inkey client"client-key.pem -out client"client.p12

4.4.2.5 安装信任的根证书
把ca"ca-key.pem改名为ca"ca-key.cer，在client端的IE中使用"工具 ' Internet选项 ' 内容 ' 证书 ' 导入"把我们生成的CA根证书导入，使其成为用户信任的CA。

4.4.3 安装个人证书
把client.p12导入到client端的IE中作为个人证书，导入过程同4.4.2.5。

4.5 用IE浏览器使用SSL协议访问Tomcat

4.5.1 启动Tomcat 4.x
执行%TCAT_HOME%"bin"startup.bat启动Tomcat 4.x

4.5.2 用IE访问Tomcat 4.x
在IE浏览器的地址栏中输入https://localhost:8443，如果前面的操作都正确的话，应该可以看到Tomcat的欢迎页面。同时状态栏上的小锁处于闭合状态，表示您已经成功地与服务器建立了要求客户端验证的SSL安全连接。

5 结论
以 上我们实现了为Tomcat 4.x配置要求客户端验证的SSL的全过程。对于其它类型的服务器，例如Apache，Netscape Enterprise Server, Websphere，Weblogic等，一般只是在服务器端保存证书的方式略有不同，但它们的原理都是类似的，配置时可以在本文中办法的基础上做出相应 的调整。

参考资料

• Tomcat SSL Configuration HOW-TO
• SSL3.0规范
• Deion of the Secure Sockets Layer (SSL) Handshake (Q257591)
• keytool - Key and Certificate Management Tool
• Openssl使用手册