HTTPS = 对称加密 + 非对称加密 + 认证 + 完整性保护。
在了解HTTPS的基础上首先需要了解以下几点：
HTTP 的缺点：
- 通信使用明文，内容可能会被窃听
- 不验证通信者的身份，因此有可能遭遇伪装
- 无法证明报文的完整性，所以有可能已遭篡改
所以 HTTP 在需要安全传输的时候很难保证安全性。
对称加密
简化一下就是客户端可以通过加密算法 f 把数据 data 混合 key 之后生成密文 X，服务商可以通过解密算法 f' 把密文 X 混合 key 之后解密出数据 data。
服务端可以通过加密算法 f 把数据 data' 混合 key 之后生成密文 X'，客户端可以通过解密算法 f' 把密文 X' 混合 key 之后解密出数据 data'。
客户端
加密 => f(key, data) => X
解密 => f'(key, X') => data'
服务端
解密 => f'(key, X) => data
加密 => f(key, data') => X'
那么对称加密的不安全性在什么地方？
title: 正常通信
Client->Server: 请求 key
Server->Client: key
Client->Client: f(key, data) => X
Client->Server: X
Server->Server: f'(key, X) => data
Server->Server: f(key, data) => X'
Server->Client: X'
Client->Client: f'(key, X') => data'
Title: 被黑客攻击的通信
participant Client as C
participant Hacker as H
participant Server as S
C->H: 请求 key
H->S: 请求 key
S->H: key
H->C: key
C->C: f(key, data) => X
C->H: X
H->H: f'(key, X) => data
H->H: 纂改 data => other
H->H: f(key, other) => XX
H->S: XX
S->S: f'(key, XX) => other
S->H: f(key, other') => YY
H->H: f'(key, YY) => other'
H->H: 纂改 other' => another
H->H: f(key, another) => YY'
H->C: YY'
**对称加密算法的缺点是在数据传送前，发送方和接收方必须商定好秘钥，然后使双方都能保存好秘钥。其次如果一方的秘钥被泄露，那么加密信息也就不安全了。**另外，每对用户每次使用对称加密算法时，都需要使用其他人不知道的独一秘钥，这会使得收、发双方所拥有的钥匙数量巨大，密钥管理成为双方的负担。
非对称加密
简化一下就是客户端根据算法 f 配合公钥 publickey 加密数据data后得到密文 X，服务端利用算法 f 配合私钥 privatekey 解密密文 X 后就能得到数据 data。
服务端根据算法 f 配合私钥 privatekey 加密数据data'后得到密文 X'，客户端端利用算法 f 配合公钥 publickey 解密密文 X' 后就能得到数据 data'。
客户端
发送加密 => f(publickey, data) => X
接收解密 => f(publickey, X') => data
服务端
发送加密 => f(privatekey, data') => X'
接收解密 => f(publickey, X) => data
那么非对称加密的不安全性在什么地方？
title: 正常通信
participant Client as C
participant Server as S
C->S: 请求 publickey
S->C: publickey
C->C: f(publickey, data) => X
C->S: X
S->S: f(privatekey, X) => data
S->S: f(privatekey, data') => X'
S->C: X'
title: 被黑客攻击的通信
participant Client as C
participant Hacker as H
participant Server as S
C->H: 请求 publickey
H->S: 请求 publickey
S->H: publickey
H->C: publickey
C->H: f(publickey, data) => X
H->S: X
S->S: f(privatekey, X) => data
S->H: f(privatekey, data') => X'
H->H: f(publickey, X') => data'
H->C: X'
C->C: f(publickey, X') => data'
