SSL和HTTPS

SSL和HTTPS的基本概念,以及java中的api使用。

SSL

简介

  1. SSL(Secure Sockets Layer 安全套接层),及其继任者传输层安全(Transport Layer Security,TLS)是为网络通信提供安全及数据完整性的一种安全协议。TLS与SSL在传输层对网络连接进行加密。
  2. SSL (Secure Socket Layer)为Netscape所研发,用以保障在Internet上数据传输之安全,利用数据加密(Encryption)技术,可确保数据在网络上之传输过程中不会被截取及窃听。目前一般通用之规格为40 bit之安全标准,美国则已推出128 bit之更高安全标准,但限制出境。只要3.0版本以上之I.E.或Netscape浏览器即可支持SSL。
  3. 当前版本为3.0。它已被广泛地用于Web浏览器与服务器之间的身份认证和加密数据传输。
    SSL协议位于TCP/IP协议与各种应用层协议之间,为数据通讯提供安全支持。SSL协议可分为两层:SSL记录协议(SSL Record Protocol):它建立在可靠的传输协议(如TCP)之上,为高层协议提供数据封装、压缩、加密等基本功能的支持。SSL握手协议(SSL Handshake Protocol):它建立在SSL记录协议之上,用于在实际的数据传输开始前,通讯双方进行身份认证、协商加密算法、交换加密密钥等。

SSL提供的服务

  1. 认证用户和服务器,确保数据发送到正确的客户机和服务器
  2. 加密数据以防止数据中途被窃取
  3. 维护数据的完整性,确保数据在传输过程中不被改变。

SSL协议的工作流程

服务器认证阶段

  1. 客户端向服务器发送一个开始信息“Hello”以便开始一个新的会话连接;
  2. 服务器根据客户的信息确定是否需要生成新的主密钥,如需要则服务器在响应客户的“Hello”信息时将包含生成主密钥所需的信息;
  3. 客户根据收到的服务器响应信息,产生一个主密钥,并用服务器的公开密钥加密后传给服务器;
  4. 服务器恢复该主密钥,并返回给客户一个用主密钥认证的信息,以此让客户认证服务器。

用户认证阶段

在此之前,服务器已经通过了客户认证,这一阶段主要完成对客户的认证。经认证的服务器发送一个提问给客户,客户则返回(数字)签名后的提问和其公开密钥,从而向服务器提供认证。

从SSL 协议所提供的服务及其工作流程可以看出,SSL协议运行的基础是商家对消费者信息保密的承诺,这就有利于商家而不利于消费者。在电子商务初级阶段,由于运作电子商务的企业大多是信誉较高的大公司,因此这问题还没有充分暴露出来。但随着电子商务的发展,各中小型公司也参与进来,这样在电子支付过程中的单一认证问题就越来越突出。虽然在SSL3.0中通过数字签名和数字证书可实现浏览器和Web服务器双方的身份验证,但是SSL协议仍存在一些问题,比如,只能提供交易中客户与服务器间的双方认证,在涉及多方的电子交易中,SSL协议并不能协调各方间的安全传输和信任关系。在这种情况下,Visa和MasterCard两大信用卡公组织制定了SET协议,为网上信用卡支付提供了全球性的标准。

SSL协议的握手过程

SSL 协议既用到了公钥加密技术又用到了对称加密技术,对称加密技术虽然比公钥加密技术的速度快,可是公钥加密技术提供了更好的身份认证技术。SSL 的握手协议非常有效的让客户和服务器之间完成相互之间的身份认证,其主要过程如下:

  1. 客户端的浏览器向服务器传送客户端SSL 协议的版本号,加密算法的种类,产生的随机数,以及其他服务器和客户端之间通讯所需要的各种信息。
  2. 服务器向客户端传送SSL 协议的版本号,加密算法的种类,随机数以及其他相关信息,同时服务器还将向客户端传送自己的证书。
  3. 客户利用服务器传过来的信息验证服务器的合法性,服务器的合法性包括:证书是否过期,发行服务器证书的CA 是否可靠,发行者证书的公钥能否正确解开服务器证书的“发行者的数字签名”,服务器证书上的域名是否和服务器的实际域名相匹配。如果合法性验证没有通过,通讯将断开;如果合法性验证通过,将继续进行第四步。
  4. 用户端随机产生一个用于后面通讯的“对称密码”,然后用服务器的公钥(服务器的公钥从步骤②中的服务器的证书中获得)对其加密,然后将加密后的“预主密码”传给服务器。
  5. 如果服务器要求客户的身份认证(在握手过程中为可选),用户可以建立一个随机数然后对其进行数据签名,将这个含有签名的随机数和客户自己的证书以及加密过的“预主密码”一起传给服务器。
  6. 如果服务器要求客户的身份认证,服务器必须检验客户证书和签名随机数的合法性,具体的合法性验证过程包括:客户的证书使用日期是否有效,为客户提供证书的CA 是否可靠,发行CA 的公钥能否正确解开客户证书的发行CA 的数字签名,检查客户的证书是否在证书废止列表(CRL)中。检验如果没有通过,通讯立刻中断;如果验证通过,服务器将用自己的私钥解开加密的“预主密码”,然后执行一系列步骤来产生主通讯密码(客户端也将通过同样的方法产生相同的主通讯密码)。
  7. 服务器和客户端用相同的主密码即“通话密码”,一个对称密钥用于SSL 协议的安全数据通讯的加解密通讯。同时在SSL 通讯过程中还要完成数据通讯的完整性,防止数据通讯中的任何变化。
  8. 客户端向服务器端发出信息,指明后面的数据通讯将使用的步骤⑦中的主密码为对称密钥,同时通知服务器客户端的握手过程结束。
  9. 服务器向客户端发出信息,指明后面的数据通讯将使用的步骤⑦中的主密码为对称密钥,同时通知客户端服务器端的握手过程结束。
  10. SSL 的握手部分结束,SSL 安全通道的数据通讯开始,客户和服务器开始使用相同的对称密钥进行数据通讯,同时进行通讯完整性的检验。

SSL协议的握手过程

Tips

  1. 生成密钥库,密钥库中必须存放私钥和证书,此外为私钥设置的密码应该和密钥库的密码相同。服务器程序将自动从密钥库中提取证书,向客户程序表明自己是谁。
  2. 客户端欲和SSL服务器通信,则必须信任SSL服务器程序所使用的数字证书。因此客户程序应该将所信任的证书放在一个密钥库中,指定客户信任哪些证书,这样当其接收到服务器程序发来的证书后就可以判断是否相信服务器。

keytool的用法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
➜  ~ keytool -help
密钥和证书管理工具

命令:

-certreq 生成证书请求
-changealias 更改条目的别名
-delete 删除条目
-exportcert 导出证书
-genkeypair 生成密钥对
-genseckey 生成密钥
-gencert 根据证书请求生成证书
-importcert 导入证书或证书链
-importkeystore 从其他密钥库导入一个或所有条目
-keypasswd 更改条目的密钥口令
-list 列出密钥库中的条目
-printcert 打印证书内容
-printcertreq 打印证书请求的内容
-printcrl 打印 CRL 文件的内容
-storepasswd 更改密钥库的存储口令

使用keytool -command_name -help获取 command_name 的用法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
➜  ~ keytool -genkey -help
keytool -genkeypair [OPTION]...

生成密钥对

选项:

-alias <alias> 要处理的条目的别名
-keyalg <keyalg> 密钥算法名称
-keysize <keysize> 密钥位大小
-sigalg <sigalg> 签名算法名称
-destalias <destalias> 目标别名
-dname <dname> 唯一判别名
-startdate <startdate> 证书有效期开始日期/时间
-ext <value> X.509 扩展
-validity <valDays> 有效天数
-keypass <arg> 密钥口令
-keystore <keystore> 密钥库名称
-storepass <arg> 密钥库口令
-storetype <storetype> 密钥库类型
-providername <providername> 提供方名称
-providerclass <providerclass> 提供方类名
-providerarg <arg> 提供方参数
-providerpath <pathlist> 提供方类路径
-v 详细输出
-protected 通过受保护的机制的口令

使用keytool -help获取所有可用命令

1
keytool -genkey -alias xuhetest -keyalg RSA -keysize 1024 -keystore xuhetest.keystore -validity 4000 -storepass xuhe123 -keypass xuhe123

上条命令创建【alias】别名为【xuhetest】,【keyalg】密钥算法为【RSA】,【keysize】密钥位大小为【1024】,【keystore】密钥库名称为【xuhetest.keystore】,【validity】有效天数为【4000】,【storepass】密钥库口令为【xuhe123】,【keypass】密钥口令为【xuhe123】的密钥

genkey

执行完毕后将在当前用户目录下创建xuhetest.keystore文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
➜  ~ keytool -export -help
keytool -exportcert [OPTION]...

导出证书

选项:

-rfc 以 RFC 样式输出
-alias <alias> 要处理的条目的别名
-file <filename> 输出文件名
-keystore <keystore> 密钥库名称
-storepass <arg> 密钥库口令
-storetype <storetype> 密钥库类型
-providername <providername> 提供方名称
-providerclass <providerclass> 提供方类名
-providerarg <arg> 提供方参数
-providerpath <pathlist> 提供方类路径
-v 详细输出
-protected 通过受保护的机制的口令
1
keytool -export -rfc -alias xuhetest -file xuhetest.cer -keystore xuhetest.keystore -storepass xuhe123

上条命令将以【rfc】样式输出【alias】别名为【xuhetest】,【file】文件名为【xuhetest.cer】,【keystore】密钥库【xuhetest.keystore】,【storepass】密钥库口令【xuhe123】的密钥,执行完毕后将在当前用户目录下创建xuhetest.cer文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
➜  ~ keytool -import -help
keytool -importcert [OPTION]...

导入证书或证书链

选项:

-noprompt 不提示
-trustcacerts 信任来自 cacerts 的证书
-protected 通过受保护的机制的口令
-alias <alias> 要处理的条目的别名
-file <filename> 输入文件名
-keypass <arg> 密钥口令
-keystore <keystore> 密钥库名称
-storepass <arg> 密钥库口令
-storetype <storetype> 密钥库类型
-providername <providername> 提供方名称
-providerclass <providerclass> 提供方类名
-providerarg <arg> 提供方参数
-providerpath <pathlist> 提供方类路径
-v 详细输出

导入cer证书

1
keytool  -import -alias mytest -file  mytest.cer -keystore mytest.keystore
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
➜  ~ keytool -import -alias vankeEcif -file vankeEcif.cer -keystore vankeEcif.keystore
输入密钥库口令:
再次输入新口令:
所有者: CN=IBM085-P15BT8E, OU=vankeEcif, O=vanke, L=ShenZhen, ST=GuangDong, C=CN
发布者: CN=IBM085-P15BT8E, OU=vankeEcif, O=vanke, L=ShenZhen, ST=GuangDong, C=CN
序列号: 13a792c4
有效期开始日期: Tue Sep 27 20:22:23 CST 2016, 截止日期: Sat Dec 12 20:22:23 CST 2116
证书指纹:
MD5: B3:8C:11:BB:DE:5C:64:C1:DC:13:F4:19:4F:91:82:C9
SHA1: A9:9E:8C:9A:19:D0:16:4F:67:A2:31:BA:03:EF:E5:A8:08:29:28:4E
SHA256: 45:21:15:18:FF:19:12:FC:6E:A7:0D:E2:E7:44:05:25:87:5C:CE:AD:B0:6D:4D:95:38:10:33:88:50:09:EE:24
签名算法名称: SHA256withRSA
版本: 3

扩展:

#1: ObjectId: 2.5.29.14 Criticality=false
SubjectKeyIdentifier [
KeyIdentifier [
0000: 1F A8 23 CE 15 E2 BD C8 18 4D 92 59 17 A3 3C 9E ..#......M.Y..<.
0010: 9F CC 35 40 ..5@
]
]

是否信任此证书? [否]: Y
证书已添加到密钥库中

https

含义

HTTPS(全称:Hyper Text Transfer Protocol over Secure Socket Layer),是以安全为目标的HTTP通道,简单讲是HTTP的安全版。即HTTP下加入SSL层,HTTPS的安全基础是SSL,因此加密的详细内容就需要SSL。 它是一个URI scheme(抽象标识符体系),句法类同http:体系。用于安全的HTTP数据传输。https:URL表明它使用了HTTP,但HTTPS存在不同于HTTP的默认端口及一个加密/身份验证层(在HTTP与TCP之间)。这个系统的最初研发由网景公司(Netscape)进行,并内置于其浏览器Netscape Navigator中,提供了身份验证与加密通讯方法。现在它被广泛用于万维网上安全敏感的通讯,例如交易支付方面。

与http的区别

超文本传输协议HTTP协议被用于在Web浏览器和网站服务器之间传递信息。HTTP协议以明文方式发送内容,不提供任何方式的数据加密,如果攻击者截取了Web浏览器和网站服务器之间的传输报文,就可以直接读懂其中的信息,因此HTTP协议不适合传输一些敏感信息,比如信用卡号、密码等。为了解决HTTP协议的这一缺陷,需要使用另一种协议:安全套接字层超文本传输协议HTTPS。为了数据传输的安全,HTTPS在HTTP的基础上加入了SSL协议,SSL依靠证书来验证服务器的身份,并为浏览器和服务器之间的通信加密。HTTPS和HTTP的区别主要为以下四点:

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

解决问题

信任主机的问题

采用https的服务器必须从CA (Certificate Authority)申请一个用于证明服务器用途类型的证书。该证书只有用于对应的服务器的时候,客户端才信任此主机。所以所有的银行系统网站,关键部分应用都是https 的。客户通过信任该证书,从而信任了该主机。其实这样做效率很低,但是银行更侧重安全。这一点对局域网对内提供服务处的服务器没有任何意义。局域网中的服务器,采用的证书不管是自己发布的还是从公众的地方发布的,其客户端都是自己人,所以该局域网中的客户端也就肯定信任该服务器。

通讯过程中的数据的泄密和被篡改

  1. 一般意义上的https,就是服务器有一个证书。
    1. 主要目的是保证服务器就是他声称的服务器,这个跟第一点一样。
    2. 服务端和客户端之间的所有通讯,都是加密的。
      1. 具体讲,是客户端产生一个对称的密钥,通过服务器的证书来交换密钥,即一般意义上的握手过程。
      2. 接下来所有的信息往来就都是加密的。第三方即使截获,也没有任何意义,因为他没有密钥,当然篡改也就没有什么意义了。
  2. 少许对客户端有要求的情况下,会要求客户端也必须有一个证书。
    1. 这里客户端证书,其实就类似表示个人信息的时候,除了用户名/密码,还有一个CA 认证过的身份。因为个人证书一般来说是别人无法模拟的,所有这样能够更深的确认自己的身份。
    2. 目前大多数个人银行的专业版是这种做法,具体证书可能是拿U盘(即U盾)作为一个备份的载体。

java代码

server端

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
package service.test;


import com.sun.net.httpserver.*;

import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import java.io.*;
import java.net.InetSocketAddress;
import java.security.KeyStore;


public class TestHttpsServer {

public static void main(String[] args) throws Exception {
//实现HTTP SERVER
// HttpServer hs = HttpServer.create(new InetSocketAddress(8080), 0);// 设置HttpServer的端口为80
// hs.createContext("/user/test", new MyHandler());// 用MyHandler类内处理到/的请求
// hs.setExecutor(null); // creates a default executor
// hs.start();

//实现HTTPS SERVER
HttpsServer hss = HttpsServer.create(new InetSocketAddress(8080), 0); //设置HTTPS端口
KeyStore ks = KeyStore.getInstance("JKS"); //建立证书库
ks.load(new FileInputStream("/Users/xuhe/xuhetest.keystore"), "xuhe123".toCharArray()); //载入证书
KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509"); //建立一个密钥管理工厂
kmf.init(ks, "xuhe123".toCharArray()); //初始工厂
SSLContext sslContext = SSLContext.getInstance("SSLv3"); //建立证书实体
sslContext.init(kmf.getKeyManagers(), null, null); //初始化证书
HttpsConfigurator conf = new HttpsConfigurator(sslContext);//在https配置
hss.setHttpsConfigurator(conf); //在https server载入配置
hss.setExecutor(null); // creates a default executor
hss.createContext("/user/test", new MyHandler());// 用MyHandler类内处理到/的请求
hss.start();

}

}

class MyHandler implements HttpHandler {
public void handle(HttpExchange t) throws IOException {
System.out.println(t.getRemoteAddress().getAddress());
InputStream is = t.getRequestBody();
Headers headers = t.getRequestHeaders();
for (String key : headers.keySet()) {
System.out.println(key+":"+headers.get(key));
}
BufferedReader br = null;

try {
br = new BufferedReader(new InputStreamReader(is, "utf-8"));
String line = null;
StringBuilder sb = new StringBuilder();
while ((line = br.readLine()) != null) {
sb.append(line);
}
System.out.println(sb);
} finally {
br.close();
}

String response = "<font color='#ff0000'>hello world</font>";
t.sendResponseHeaders(200, response.length());
OutputStream os = t.getResponseBody();
os.write(response.getBytes());
os.close();
}
}

client端java原生版本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
package service.test;

import javax.net.ssl.*;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.net.URL;
import java.security.KeyStore;

public class TestHttpsClient {

public static void main(String[] args) throws Exception {
KeyStore keystore = KeyStore.getInstance("JKS"); //创建一个keystore来管理密钥库
// String path = getWebPath()+ keystorePath;
keystore.load(new FileInputStream("/Users/xuhe/xuhetest.keystore"), "xuhe123".toCharArray());
//创建jkd密钥访问库
TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");
tmf.init(keystore); //验证数据,可以不传入key密码
//创建TrustManagerFactory,管理授权证书
SSLContext sslc = SSLContext.getInstance("SSLv3");
// 构造SSL环境,指定SSL版本为3.0,也可以使用TLSv1,但是SSLv3更加常用。
sslc.init(null, tmf.getTrustManagers(), null);
//KeyManager[] 第一个参数是授权的密钥管理器,用来授权验证。第二个是被授权的证书管理器,
//用来验证服务器端的证书。只验证服务器数据,第一个管理器可以为null
//构造ssl环境
HttpsURLConnection.setDefaultSSLSocketFactory(sslc.getSocketFactory());
HttpsURLConnection.setDefaultHostnameVerifier(new HostnameVerifier() {
@Override
public boolean verify(String s, SSLSession sslSession) {
return true;
}
});

HttpsURLConnection conn = null;
BufferedReader reader = null;

try {
// 创建连接
conn = (HttpsURLConnection) new URL("https://localhost:8080/user/test").openConnection();
conn.setRequestMethod("GET");
conn.setDoInput(true);
conn.setDoOutput(true);
reader = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"));

StringBuilder sb = new StringBuilder();
String line;
while ((line = reader.readLine()) != null) {
sb.append(line);
}

System.out.println(sb);
} finally {
if (reader != null) {
reader.close();
}
if (conn != null) {
conn.disconnect();
}
}
}

}

client端appache client版本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
package org.apache.http.examples.client;

import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.TrustSelfSignedStrategy;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.ssl.SSLContexts;
import org.apache.http.util.EntityUtils;

import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import java.io.File;

public class ClientCustomSSL {

public final static void main(String[] args) throws Exception {
// Trust own CA and all self-signed certs
SSLContext sslcontext = SSLContexts.custom()
.loadTrustMaterial(new File("/Users/xuhe/xuhetest.keystore"), "xuhe123".toCharArray(),
new TrustSelfSignedStrategy())
.build();
// 或者直接采用
//SSLContext sslcontext = SSLContexts.custom().loadTrustMaterial(new TrustSelfSignedStrategy()).build();
// Allow TLSv1 protocol only
SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
sslcontext,
new String[]{"TLSv1"},
null,
new HostnameVerifier() {
@Override
public boolean verify(String s, SSLSession sslSession) {
return true;
}
});
CloseableHttpClient httpclient = HttpClients.custom()
.setSSLSocketFactory(sslsf)
.build();
try {

HttpGet httpget = new HttpGet("https://localhost:8080/user/test");

System.out.println("Executing request " + httpget.getRequestLine());

CloseableHttpResponse response = httpclient.execute(httpget);
try {
HttpEntity entity = response.getEntity();

System.out.println("----------------------------------------");
System.out.println(response.getStatusLine());
System.out.println(EntityUtils.toString(entity));
System.out.println("----------------------------------------");
EntityUtils.consume(entity);
} finally {
response.close();
}
} finally {
httpclient.close();
}
}

}