PHPor 的Blog – 第174页

关于keep-alive

你的服务器是否打开了keep-alive 呢？看看httpd.conf 就知道了，但是也不是必须的，简单测试一下就知道了，用第三个请求比较稳妥一些，看看下面的几个请求，顺便理解一下HTTP/1.0 与 HTTP/1.1 的几个区别：

请求1：
———————————-
GET / HTTP/1.1
Host: phpor.net

返回结果的编码格式：Transfer-Encoding: chunked
没有立即关闭连接，说明：HTTP/1.1 默认支持（启用）keep-alive

———————————-

请求2：
———————————-
GET / HTTP/1.0
Host: pengyou.sina.com.cn
Connection: Keep-Alive

返回结果的编码格式：Content-Length: 5556 说明： HTTP/1.0 还不支持Transfer-Encoding: chunked的传输编码方式
没有立即关闭连接，说明：HTTP/1.0 也可以使用 keep-alive
———————————-

请求3：
———————————-
GET / HTTP/1.1
Host: phpor.net
Connection: Keep-Alive

这个就肯定keep-alive了
———————————-
请求4：
———————————-
GET / HTTP/1.0
Host: phpor.net

这个请求就；
1. 不能Transfer-Encoding: chunked
2. 不能keep-alive
———————————-

结论：
要了解某个server是否打开了keep-alive ，只需用telnet发一个类似于前三种的请求，看看是否立即关闭了就行了

全组合之 PHP实现

<?php
$arr = array(
array(‘A1’,‘A2’),
array(‘B1’,‘B2’),
array(‘C1’,‘C2’)
);

print_r(zuhe($arr,false));
// or
zuhe($arr,true);

/**
* @param: $arr: array for deal
* @param: $echo: print at end or not
*/
function zuhe($arr, $echo = true) {
$len = count($arr);
if ($len == 0 ) return array();
if ($len == 1) {
if ($echo) {
foreach( $arr[0] as $val) {
echo $val ."\n";
}
} else {
return $arr[0];
}
exit();
}
$tmparr = array();
foreach($arr[0] as $val0) {
foreach($arr[1] as $val1) {
$tmparr[] = $val0 ."\t". $val1;
}
}
array_shift($arr);
array_shift($arr);
array_unshift($arr, $tmparr);
return zuhe($arr, $echo);
}
/**
* result:
* A1 B1 C1
* A1 B1 C2
* A1 B2 C1
* A1 B2 C2
* A2 B1 C1
* ….
* A2 B2 C2
*/
?>

实现2：

<?php

$arr = array(
    ‘gateway’=>array(‘set’,‘noset’),
    ‘returntype’=>array(‘META’,‘TEXT’,‘TEXT2’),
    ‘url’=>array(‘login.php’,‘set&not_login.php’,‘noset’),
    ‘st’=>array(‘ok’,‘err’,‘no’)
);

echo implode("\t\t\t\t",array_keys($arr))."\n"."\n";
//print_r(zuhe($arr,false));
// or
zuhe($arr,true, –20);

/**
* @param: $arr: array for deal
* @param: $echo: print at end or not
*/
function zuhe($arr, $echo = true, $width = "\t") {
    $len = count($arr);
    if ($len == 0 ) return array();
    if ($len == 1) {
        if ($echo) {
            foreach( $arr[0] as $val) {
                echo $val ."\n";
            }
        } else {
            return $arr[0];
        }
        exit();
    }
    $tmparr = array();
    $arr0 = array_shift($arr);
    $arr1 = array_shift($arr);
    foreach($arr0 as $val0) {
        foreach($arr1 as $val1) {
            if ($width == "auto") {
                // 希望能自动调整列宽,为实现
            }else if ($width == "\t") {
                $tmparr[] = $val0 ."\t". $val1;
            } else {
                $tmparr[] = sprintf("%${width}s",$val0) .sprintf("%${width}s",$val1);
            }
        }
    }

    array_unshift($arr, $tmparr);
    return zuhe($arr, $echo, $width);
}
/**
* result:
* A1    B1    C1
* A1     B1  C2
* A1   B2  C1
* A1   B2  C2
* A2   B1  C1
* ….
* A2   B2  C2
*/

利用openssl创建一个简单的CA

本文旨在利用开源openssl软件，在Linux（或UNIX/Cygwin）下创建一个简单的CA。我们可以利用这个CA进行PKI、数字证书相关的测试。比如，在测试用Tomcat或Apache构建HTTPS双向认证时，我们可以利用自己建立的测试CA来为服务器端颁发服务器数字证书，为客户端（浏览器）生成文件形式的数字证书（可以同时利用openssl生成客户端私钥）。

该简单的CA将建立在用户自己的目录下（$HOME/testca），无需超级用户（root）权限。

一. 创建CA
1. 创建CA需要用到的目录和文件：
执行命令如下：
mkdir "$HOME/testca"
cd "$HOME/testca"
mkdir newcerts private conf
chmod g-rwx,o-rwx private
echo "01" > serial
touch index.txt

说明：
$HOME/testca为待建CA的主目录。其中newcerts子目录将存放CA签署（颁发）过的数字证书（证书备份目录）。而private目录用于存放CA的私钥。目录conf只是用于存放一些简化参数用的配置文件。

文件serial和index.txt分别用于存放下一个证书的序列号和证书信息数据库。
当然，偷懒起见，可以只用按照本文操作即可，不一定需要关心各个目录和文件的作用。

2. 生成CA的私钥和自签名证书（即根证书）
创建文件：
vi "$HOME/testca/conf/gentestca.conf"
文件内容如下：
####################################
[ req ]
default_keyfile = $ENV::HOME/testca/private/cakey.pem
default_md = md5
prompt = no
distinguished_name = ca_distinguished_name
x509_extensions = ca_extensions

[ ca_distinguished_name ]
organizationName = TestOrg
organizationalUnitName = TestDepartment
commonName = TestCA
emailAddress = ca_admin@testorg.com

[ ca_extensions ]
basicConstraints = CA:true
########################################

然后执行命令如下：
cd "$HOME/testca"
openssl req -x509 -newkey rsa:2048 -out cacert.pem -outform PEM -days 2190 -config "$HOME/testca/conf/gentestca.conf"
执行过程中需要输入CA私钥的保护密码，假设我们输入密码： 888888

可以用如下命令查看一下CA自己证书的内容
openssl x509 -in cacert.pem -text -noout

3. 创建一个配置文件，以便后续CA日常操作中使用：
vi "$HOME/testca/conf/testca.conf"
文件内容如下：
####################################
[ ca ]
default_ca = testca # The default ca section

[ testca ]
dir = $ENV::HOME/testca # top dir
database = $dir/index.txt # index file.
new_certs_dir = $dir/newcerts # new certs dir

certificate = $dir/cacert.pem # The CA cert
serial = $dir/serial # serial no file
private_key = $dir/private/cakey.pem # CA private key
RANDFILE = $dir/private/.rand # random number file

default_days = 365 # how long to certify for
default_crl_days= 30 # how long before next CRL
default_md = md5 # message digest method to use
unique_subject = no # Set to ‘no’ to allow creation of
# several ctificates with same subject.
policy = policy_any # default policy

[ policy_any ]
countryName = optional
stateOrProvinceName = optional
localityName = optional
organizationName = optional
organizationalUnitName = optional
commonName = supplied
emailAddress = optional

########################################

二. CA的日常操作
1. 根据证书申请请求签发证书
假设收到一个证书请求文件名为req.pem，文件格式应该是PKCS#10格式（标准证书请求格式）。

首先可以查看一下证书请求的内容，执行命令：
openssl req -in req.pem -text -noout
将看到证书请求的内容，包括请求者唯一的名字（DN）、公钥信息（可能还有一组扩展的可选属性）。

执行签发命令：
openssl ca -in req.pem -out cert.pem -config "$HOME/testca/conf/testca.conf"
执行过程中会要求输入访问CA的私钥密码（刚才设置的888888）。

完成上一步后，签发好的证书就是cert.pem，另外$HOME/testca/newcerts里也会有一个相同的证书副本（文件名为证书序列号）。
你可以执行以下语句来查看生成的证书的内容：
openssl x509 -in cert.pem -text -noout

2. 吊销证书（作废证书）
一般由于用户私钥泄露等情况才需要吊销一个未过期的证书。（当然我们用本测试CA时其时很少用到该命令，除非专门用于测试吊销证书的情况）
假设需要被吊销的证书文件为cert.pem，则执行以下命令吊销证书：
openssl ca -revoke cert.pem -config "$HOME/testca/conf/testca.conf"

3. 生成证书吊销列表文件（CRL）
准备公开被吊销的证书列表时，可以生成证书吊销列表（CRL），执行命令如下：
openssl ca -gencrl -out testca.crl -config "$HOME/testca/conf/testca.conf"
还可以添加-crldays和-crlhours参数来说明下一个吊销列表将在多少天后（或多少小时候）发布。

可以用以下命令检查testca.crl的内容：
openssl crl -in testca.crl -text -noout

三. 自己生成公钥密钥，并用测试CA签发数字证书
我们在平时测试时，可以自己用openssl为服务器或用户生成公钥密钥，并用上面创建的CA签发对应私钥（密钥）的数字证书。
假设，我们就用刚才创建CA的操作系统用户为名为testuser的用户创建数字证书，我们要把待创建的私钥、证书等都放在目录$HOME/testuser下：

1. 创建密钥和证书请求（证书请求里包含了公钥）
创建$HOME/testuser目录并执行命令：
mkdir $HOME/testuser
cd $HOME/testuser
openssl req -newkey rsa:1024 -keyout testkey.pem -keyform PEM -out testreq.pem -outform PEM -subj "/O=TestCom/OU=TestOU/CN=testuser"
执行过程中需要输入私钥的保护密码，假设我们输入密码： 222222

执行完后，testkey.pem即为用户的密钥，而testreq.pem即为证书请求。
可以用openssl req -in testreq.pem -text -noout查看证书请求的内容。

2. 用测试CA为testuser签发证书
同样还在$HOME/testuser目录下执行命令：
openssl ca -in testreq.pem -out testcert.pem -config "$HOME/testca/conf/testca.conf"
执行过程中需要输入CA的密钥保护密码（刚才设置的888888），并且最后询问你是否要给该用户签发证书时要选y。

执行完后，testcert.pem即为证书，
可以用命令openssl x509 -in testcert.pem -text -noout查看证书内容。

3. 制作一个PKCS12格式的文档（个人数字证书）
我们制作的这个PKCS#12文件将包含密钥、证书和颁发该证书的CA证书。该文件可以直接用于服务器数字证书或个人数字证书。
把前几步生成的密钥和证书制作成一个pkcs12文件的方法执行命令：
openssl pkcs12 -export -in testcert.pem -inkey testkey.pem -out testuser.p12 -name testuser -chain -CAfile "$HOME/testca/cacert.pem"
执行过程中需要输入保护密钥的密码（222222），以及新的保护pkcs12文件的密码。

执行完后，testuser.p12即为pkcs12文件。你可以直接拷贝到windows下，作为个人数字证书，双击导入IE后就可以使用了。该文件也可以直接用于tomcat作为服务器证书使用（我尽量在近期再写一篇关于如何自己用tomcat建立HTTPS双向认证测试环境的文章）。

若要查看testuser.p12的内容可以用命令openssl pkcs12 -in testuser.p12

说明：
– 本文中名词“个人数字证书”意识为包含私钥和证书的实体，而不是单指只保护公钥的数字证书。
– openssl版本OpenSSL 0.9.8g 19

JAVA 双向SSL，SOCKET客户端/服务端

实现技术：
JSSE（Java Security Socket Extension）
Server需要：
1）KeyStore: 其中保存服务端的私钥
2）Trust KeyStore:其中保存客户端的授权证书
Client需要：
1）KeyStore：其中保存客户端的私钥
2）Trust KeyStore：其中保存服务端的授权证书

使用Java自带的keytool命令，去生成这样信息文件：

1）生成服务端私钥，并且导入到服务端KeyStore文件中

2）根据私钥，导出服务端证书

3）将服务端证书，导入到客户端的Trust KeyStore中

采用同样的方法，生成客户端的私钥，客户端的证书，并且导入到服务端的Trust KeyStore中
1）keytool -genkey -alias clientkey -keystore kclient.keystore
2）keytool -export -alias clientkey -keystore kclient.keystore -file client.crt
3）keytool -import -alias clientkey -file client.crt -keystore tserver.keystore

Server：
Java代码
public class Server implements Runnable{

    private static final int     DEFAULT_PORT                     = 7777;

    private static final String SERVER_KEY_STORE_PASSWORD        = "123456";
    private static final String SERVER_TRUST_KEY_STORE_PASSWORD = "123456";

    private SSLServerSocket      serverSocket;

    /**
      * 启动程序
      *
      * @param args
      */
    public static void main(String[] args) {
         Server server = new Server();
         server.init();
         Thread thread = new Thread(server);
         thread.start();
     }

    public synchronized void start() {
        if (serverSocket == null) {
             System.out.println("ERROR");
            return;
         }
        while (true) {
            try {
                 Socket s = serverSocket.accept();
                 InputStream input = s.getInputStream();
                 OutputStream output = s.getOutputStream();

                 BufferedInputStream bis = new BufferedInputStream(input);
                 BufferedOutputStream bos = new BufferedOutputStream(output);

                byte[] buffer = new byte[20];
                 bis.read(buffer);
                 System.out.println("——receive:——–"+new String(buffer).toString());

                 bos.write("yes".getBytes());
                 bos.flush();

                 s.close();
             } catch (Exception e) {
                 System.out.println(e);
             }
         }
     }
    public void init() {
        try {
             SSLContext ctx = SSLContext.getInstance("SSL");

             KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
             TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");

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

             ks.load(new FileInputStream("src/ssl/kserver.keystore"), SERVER_KEY_STORE_PASSWORD.toCharArray());
             tks.load(new FileInputStream("src/ssl/tserver.keystore"), SERVER_TRUST_KEY_STORE_PASSWORD.toCharArray());

             kmf.init(ks, SERVER_KEY_STORE_PASSWORD.toCharArray());
             tmf.init(tks);

             ctx.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);

             serverSocket = (SSLServerSocket) ctx.getServerSocketFactory().createServerSocket(DEFAULT_PORT);
             serverSocket.setNeedClientAuth(true);
         } catch (Exception e) {
             System.out.println(e);
         }
     }

    public void run() {
        // TODO Auto-generated method stub
         start();
     }
}

Client：
Java代码
package ssl;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.security.KeyStore;

import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocket;
import javax.net.ssl.TrustManagerFactory;

/**
* SSL Client
*
* @author Leo
*/
public class Client {

    private static final String DEFAULT_HOST                     = "127.0.0.1";
    private static final int     DEFAULT_PORT                     = 7777;

    private static final String CLIENT_KEY_STORE_PASSWORD        = "123456";
    private static final String CLIENT_TRUST_KEY_STORE_PASSWORD = "123456";

    private SSLSocket            sslSocket;

    /**
      * 启动客户端程序
      *
      * @param args
      */
    public static void main(String[] args) {
        Client client = new Client();
         client.init();
         client.process();
     }


    public void process() {
        if (sslSocket == null) {
             System.out.println("ERROR");
            return;
         }
        try {
             InputStream input = sslSocket.getInputStream();
             OutputStream output = sslSocket.getOutputStream();

             BufferedInputStream bis = new BufferedInputStream(input);
             BufferedOutputStream bos = new BufferedOutputStream(output);

             bos.write("1234567890".getBytes());
             bos.flush();

            byte[] buffer = new byte[20];
             bis.read(buffer);
             System.out.println(new String(buffer));

             sslSocket.close();
         } catch (IOException e) {
             System.out.println(e);
         }
     }


    public void init() {
        try {
             SSLContext ctx = SSLContext.getInstance("SSL");

             KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
             TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");

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

             ks.load(new FileInputStream("src/ssl/kclient.keystore"), CLIENT_KEY_STORE_PASSWORD.toCharArray());
             tks.load(new FileInputStream("src/ssl/tclient.keystore"), CLIENT_TRUST_KEY_STORE_PASSWORD.toCharArray());

             kmf.init(ks, CLIENT_KEY_STORE_PASSWORD.toCharArray());
             tmf.init(tks);

             ctx.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);

             sslSocket = (SSLSocket) ctx.getSocketFactory().createSocket(DEFAULT_HOST, DEFAULT_PORT);
         } catch (Exception e) {
             System.out.println(e);
         }
     }

}

启动Server

启动Client，发送信息。

Server接收如下：正确解密
返回Client信息，

如此，就完成了服务端和客户端之间的基于身份认证的交互。

client采用kclient.keystore中的clientkey私钥进行数据加密，发送给server。
server采用tserver.keystore中的client.crt证书（包含了clientkey的公钥）对数据解密，如果解密成功，证明消息来自client，进行逻辑处理。

server采用kserver.keystore中的serverkey私钥进行数据加密，发送给client。
client采用tclient.keystore中的server.crt证书（包含了serverkey的公钥）对数据解密，如果解密成功，证明消息来自server，进行逻辑处理。

如果过程中，解密失败，那么证明消息来源错误。不进行逻辑处理。这样就完成了双向的身份认证。

keytools简介

keytool JAVA是个密钥和证书管理工具。它使用户能够管理自己的公钥/私钥对及相关证书，用于（通过数字签名）自我认证（用户向别的用户/服务认证自己）或数据完整性以及认证服务。它还允许用户储存他们的通信对等者的公钥（以证书形式）。通过keytool –help查看其用法;

创建证书Java 中的 keytool.exe （位于 JDK/Bin 目录下）可以用来创建数字证书，所有的数字证书是以一条一条(采用别名区别)的形式存入证书库的中，证书库中的一条证书包含该条证书的私钥，公钥和对应的数字证书的信息。证书库中的一条证书可以导出数字证书文件，数字证书文件只包括主体信息和对应的公钥。
每一个证书库是一个文件组成，它有访问密码，在首次创建时，它会自动生成证书库，并要求指定访问证书库的密码。
在创建证书的的时候，需要填写证书的一些信息和证书对应的私钥密码。这些信息包括 CN=xx,OU=xx,O=xx,L=xx,ST=xx,C=xx，它们的意思是：
Ø CN（Common Name – 名字与姓氏）：其实这个“名字与姓氏”应该是域名，比如说localhost或是blog.devep.net之类的。输成了姓名，和真正运行的时候域名不符，会出问题。浏览器访问时，弹出一个对话框，提示“安全证书上的名称无效，或者与站点名称不匹配”，用户选择继续还是可以浏览网页。但是用http client写程序访问的时候，会抛出类似于“javax.servlet.ServletException: HTTPS hostname wrong: should be ”的异常。
Ø OU（Organization Unit – 组织单位名称）
Ø O（Organization – 组织名称）
Ø L（Locality – 城市或区域名称）
Ø ST（State – 州或省份名称）
Ø C（Country – 国家名称）
可以采用交互式让工具提示输入以上信息，也可以采用参数，如：-dname “CN=xx,OU=xx,O=xx,L=xx,ST=xx,C=xx”来自动创建。

创建一个证书
指定证书库为 D:/keystore/test，创建别名为 Tomcat 的一条证书，它指定用 RSA 算法生成，且指定密钥长度为 1024，证书有效期为 1 年：
keytool -genkey -alias Tomcat -keyalg RSA -keysize 1024 -keystore C:/keystore/test -validity 365
显示证书库中的证书使用如下命令： keytool -list -keystore C:/keystore/test 将显示 C:/keystore/test 证书库的的所有证书列表

导出到证书文件
使用命令：keytool -export -alias Tomcat -file C:/keystore/TC.cer -keystore C:/keystore/test 将把证书库C:/keystore/test 中的别名为 Tomcat 的证书导出到 TC.cer 证书文件中，它包含证书主体的信息及证书的公钥，不包括私钥，可以公开。
导出的证书文件是以二进制编码文件，无法用文本编辑器正确显示，可以加上 -rfc参数以一种可打印的编者编码输出。如：
keytool -export -alias Tomcat -file C:/keystore/TC.cer -keystore C:/keystore/test –rfc

查看证书的信息
通过命令: keytool -printcert -file D:/keystore/TC.cer 可以查看证书文件的信息。也可以在 Windows 资源管理器中双击产生的证书文件直接查看。

删除密钥库中的条目
keytool -delete -alias Tomcat -keystore C:/keystore/test
这条命令将 C:/keystore/test 库中的 Tomcat 这一条证书删除了。

修改证书条目口令
keytool -keypasswd -alias Tomcat -keystore C:/keystore/test，可以以交互的方式修改 C:/keystore/test 证书库中的条目为 Tomcat 的证书。
Keytool -keypasswd -alias Tomcat -keypass oldpasswd -new newpasswd -storepass storepasswd -keystore C:/keystore/test

这一行命令以非交互式的方式修改库中别名为 Tomcat 的证书的密码为新密码 newpasswd，行中的 oldpasswd 是指该条证书的原密码， storepasswd 是指证书库的密码。

List of HTTP status codes

http://en.wikipedia.org/wiki/List_of_HTTP_status_codes

德兰修女语录

人们经常是不讲道理的、没有逻辑的和以自我为中心的
不管怎样，你要原谅他们

即使你是友善的，人们可能还是会说你自私和动机不良
不管怎样，你还是要友善

当你功成名就，你会有一些虚假的朋友
和一些真实的敌人
不管怎样，你还是要取得成功

即使你是诚实的和率直的，人们可能还是会欺骗你
不管怎样，你还是要诚实和率直

你多年来营造的东西
有人在一夜之间把它摧毁
不管怎样，你还是要去营造

如果你找到了平静和幸福，他们可能会嫉妒你
不管怎样，你还是要快乐

你今天做的善事，人们往往明天就会忘记
不管怎样，你还是要做善事

即使把你最好的东西给了这个世界
也许这些东西永远都不够
不管怎样，把你最好的东西给这个世界

你看，说到底，它是你和上帝之间的事
而决不是你和他人之间的事

家用路由器设置实战

关于如何设置路由器，其实说明书里已经讲的很明白了，这里我只说几个安全配置方面的问题

1、根据mac地址限制访问

我这里有两台pc，一个虚拟的pc，一个iphone，虚拟的pc是通过桥接的方式上网的，虽然也是从路由器那里动态获取ip地址的，但是，并不需要将虚拟pc的mac地址加入到允许的mac地址列表里，因为走的是桥接模式（什么是桥接模式，我也不清楚了），所以最后允许的mac地址只有三个就可以了，就是两个pc的无线网卡的物理地址，和iphone的wifi的物理地址。

注意：

1. mac地址一定要加在： . 安全设置=》mac地址过滤里面，而不是：无线参数=>mac 地址过滤里面

2. 一定要打开安全设置=》防火墙设置里面的 “开启防火墙” 这个总的开关

2、端口转发的配置

如果LAN里的一个机器想提供服务，如：sshd httpd，那么从
转发规则=》虚拟服务器里添加指定的端口转发到提供服务的ip就行了；然后使用该路由器的wan口的ip和配置的port，就可以访问到私网ip的指定服务了；这就是路由器的nat模式

IPSec基础－IPSec服务

IPSec 协议不是一个单独的协议，它给出了应用于IP层上网络数据安全的一整套体系结构，包括网络认证协议 Authentication Header（AH）、封装安全载荷协议Encapsulating Security Payload（ESP）、密钥管理协议Internet Key Exchange （IKE）和用于网络认证及加密的一些算法等。IPSec 规定了如何在对等层之间选择安全协议、确定安全算法和密钥交换，向上提供了访问控制、数据源认证、数据加密等网络安全服务。

　　一、安全特性

　　IPSec的安全特性主要有：

　　 ·不可否认性 "不可否认性"可以证实消息发送方是唯一可能的发送者，发送者不能否认发送过消息。"不可否认性"是采用公钥技术的一个特征，当使用公钥技术时，发送方用私钥产生一个数字签名随消息一起发送，接收方用发送者的公钥来验证数字签名。由于在理论上只有发送者才唯一拥有私钥，也只有发送者才可能产生该数字签名，所以只要数字签名通过验证，发送者就不能否认曾发送过该消息。但"不可否认性"不是基于认证的共享密钥技术的特征，因为在基于认证的共享密钥技术中，发送方和接收方掌握相同的密钥。
　　·反重播性 "反重播"确保每个IP包的唯一性，保证信息万一被截取复制后，不能再被重新利用、重新传输回目的地址。该特性可以防止攻击者截取破译信息后，再用相同的信息包冒取非法访问权（即使这种冒取行为发生在数月之后）。
　　·数据完整性防止传输过程中数据被篡改，确保发出数据和接收数据的一致性。IPSec利用Hash函数为每个数据包产生一个加密检查和，接收方在打开包前先计算检查和，若包遭篡改导致检查和不相符，数据包即被丢弃。
　　·数据可靠性（加密）在传输前，对数据进行加密，可以保证在传输过程中，即使数据包遭截取，信息也无法被读。该特性在IPSec中为可选项，与IPSec策略的具体设置相关。
　　·认证数据源发送信任状，由接收方验证信任状的合法性，只有通过认证的系统才可以建立通信连接。

　　二、基于电子证书的公钥认证

　　一个架构良好的公钥体系，在信任状的传递中不造成任何信息外泄，能解决很多安全问题。IPSec与特定的公钥体系相结合，可以提供基于电子证书的认证。公钥证书认证在Windows 2000中，适用于对非Windows 2000主机、独立主机，非信任域成员的客户机、或者不运行Kerberos v5认证协议的主机进行身份认证。

　　三、预置共享密钥认证

　　IPSec也可以使用预置共享密钥进行认证。预共享意味着通信双方必须在IPSec策略设置中就共享的密钥达成一致。之后在安全协商过程中，信息在传输前使用共享密钥加密，接收端使用同样的密钥解密，如果接收方能够解密，即被认为可以通过认证。但在Windows 2000 IPSec策略中，这种认证方式被认为不够安全而一般不推荐使用。

　　四、公钥加密

　　IPSec的公钥加密用于身份认证和密钥交换。公钥加密，也被称为"不对称加密法"，即加解密过程需要两把不同的密钥，一把用来产生数字签名和加密数据，另一把用来验证数字签名和对数据进行解密。

　　使用公钥加密法，每个用户拥有一个密钥对，其中私钥仅为其个人所知，公钥则可分发给任意需要与之进行加密通信的人。例如：A想要发送加密信息给B，则A需要用B的公钥加密信息，之后只有B才能用他的私钥对该加密信息进行解密。虽然密钥对中两把钥匙彼此相关，但要想从其中一把来推导出另一把，以目前计算机的运算能力来看，这种做法几乎完全不现实。因此，在这种加密法中，公钥可以广为分发，而私钥则需要仔细地妥善保管。

　　五、Hash函数和数据完整性

　　Hash信息验证码HMAC（Hash message authentication codes）验证接收消息和发送消息的完全一致性（完整性）。这在数据交换中非常关键，尤其当传输媒介如公共网络中不提供安全保证时更显其重要性。

　　HMAC结合hash算法和共享密钥提供完整性。Hash散列通常也被当成是数字签名，但这种说法不够准确，两者的区别在于：Hash散列使用共享密钥，而数字签名基于公钥技术。hash算法也称为消息摘要或单向转换。称它为单向转换是因为：

　　1）双方必须在通信的两个端头处各自执行Hash函数计算；
　　2）使用Hash函数很容易从消息计算出消息摘要，但其逆向反演过程以目前计算机的运算能力几乎不可实现。

　　Hash散列本身就是所谓加密检查和或消息完整性编码MIC（Message Integrity Code），通信双方必须各自执行函数计算来验证消息。举例来说，发送方首先使用HMAC算法和共享密钥计算消息检查和，然后将计算结果A封装进数据包中一起发送；接收方再对所接收的消息执行HMAC计算得出结果B，并将B与A进行比较。如果消息在传输中遭篡改致使B与A不一致，接收方丢弃该数据包。

　　有两种最常用的hash函数：

　　·HMAC-MD5 MD5（消息摘要5）基于RFC1321。MD5对MD4做了改进，计算速度比MD4稍慢，但安全性能得到了进一步改善。MD5在计算中使用了64个32位常数，最终生成一个128位的完整性检查和。
　　·HMAC-SHA 安全Hash算法定义在NIST FIPS 180-1，其算法以MD5为原型。 SHA在计算中使用了79个32位常数，最终产生一个160位完整性检查和。SHA检查和长度比MD5更长，因此安全性也更高。

　　六、加密和数据可靠性

　　IPSec使用的数据加密算法是DES–Data Encryption Standard（数据加密标准）。DES密钥长度为56位，在形式上是一个64位数。DES以64位（8字节）为分组对数据加密，每64位明文，经过16轮置换生成64位密文，其中每字节有1位用于奇偶校验，所以实际有效密钥长度是56位。 IPSec还支持3DES算法，3DES可提供更高的安全性，但相应地，计算速度更慢。

　　七、密钥管理

　　·动态密钥更新

　　IPSec策略使用"动态密钥更新"法来决定在一次通信中，新密钥产生的频率。动态密钥指在通信过程中，数据流被划分成一个个"数据块"，每一个"数据块"都使用不同的密钥加密，这可以保证万一攻击者中途截取了部分通信数据流和相应的密钥后，也不会危及到所有其余的通信信息的安全。动态密钥更新服务由Internet密钥交换IKE（Internet Key Exchange）提供，详见IKE介绍部分。

　　IPSec策略允许专家级用户自定义密钥生命周期。如果该值没有设置，则按缺省时间间隔自动生成新密钥。

　　·密钥长度

　　密钥长度每增加一位，可能的密钥数就会增加一倍，相应地，破解密钥的难度也会随之成指数级加大。IPSec策略提供多种加密算法，可生成多种长度不等的密钥，用户可根据不同的安全需求加以选择。

　　·Diffie-Hellman算法

　　要启动安全通讯，通信两端必须首先得到相同的共享密钥（主密钥），但共享密钥不能通过网络相互发送，因为这种做法极易泄密。

　　Diffie-Hellman算法是用于密钥交换的最早最安全的算法之一。DH算法的基本工作原理是：通信双方公开或半公开交换一些准备用来生成密钥的"材料数据"，在彼此交换过密钥生成"材料"后，两端可以各自生成出完全一样的共享密钥。在任何时候，双方都绝不交换真正的密钥。

　　通信双方交换的密钥生成"材料"，长度不等，"材料"长度越长，所生成的密钥强度也就越高，密钥破译就越困难。除进行密钥交换外，IPSec还使用DH算法生成所有其他加密密钥。

会自动销毁的script http请求

javascript使用script标签做http请求时，如果不注意script标签的回收的话，可能产生很多垃圾script标签，下面这种方法，可以执行完http请求后自动销毁：