SSL 原理的学习

SSL 原理的学习

RSA的公用密钥密码系统广泛地应用于计算机工业的认证和加密方面。

 

      公用密钥加密技术使用不对称的密钥来加密和解密，每对密钥包含一个公钥和一个私钥，公钥是公开，而且广泛分布的，而私钥从来不公开，只有自己知道。

 

      用公钥加密的数据只有私钥才能解密，相反的，用私钥加密的数据只有公钥才能解密，正是这种不对称性才使得公用密钥密码系统那么有用。

 

      认证是一个验证身份的过程，目的是使一个实体能够确信对方是他所声称的实体。

 

      下面使用{something}key 表示something 已经用密钥 key 加密或解密。

 

      实例：现在有两个家伙 A 和 B，其中 B 想要联系 A，此时 A 要验证 B 真的就是 B，其中 B有一对密钥对，一个公钥，一个私钥，首先，
     
      1，B 会偷偷的告诉 A他的公钥（如何偷偷的，马上再说）。

              * B -->A            public-key

 

      2，收到 B发送来的请求（其中包含 B 的公钥）后，A 产生了一段随机消息，并发送给了 B：
              * A -->B            rand-msg

 

      3，B收到这段 rand-msg 后，拿出自己的私钥进行了加密，并将加密后的消息返回给了 A：

              * B -->A            {rand-msg}B-private-key

 

      4，此时，A收到的是 B 发送过来的经过 B 的私钥加密后的消息，然后掏出第一个 B 发送给他的公钥去解密，并且和自己在上一次产生的rand-msg 进行比较，如果一样的话，他就会开心了，果然是 B。

 

  ====> 看上去很美

 

      一切听上去好像很完美了，可是事实并不像看上去的那么美... ...

 

      我们再举个例子，离实际生活近一点的例子，仍然是 A 和 B 两个家伙，两人都是哑巴，他们的通信都是通过传递小纸条的。其中 A胆子很小，一天到晚都呆在家里，一天，B 要去找 A，在 A 的门口敲门，

 

      1，并把一个他的公钥写在纸条上通过门缝里传给 A，

              * B -->A            b-public-key

 

      2，此时，A传了纸条给 B

              * A -->B            你是 B 吗？

 

      3，B 收到A 传来的消息，很自觉地回了消息，并且还用自己的私钥给消息加了密，可是消息好像不太对：

              * B -->A            {嗨！兄弟是我！我是 C！}b-private-key

 

      4，A从门缝里接过小纸条，再拿出 B 第一次给他的 b-public-key 进行解密，解开了，B也在门外等了好久，人没有见着，回去了... ...

 

      从这里看出，B必须对自己需要加密的东西有所了解，还有，这个私钥只有你才有！

 

 ====> 数字签名

 

      现在的改进是在第三步，当 B 接收到 A 的随机消息后，并不是简单的用私钥加密一下就好了，而是根据 A的随机消息来构造一个消息摘要，然后再对这个消息摘要进行加密。

 

      通过使用这个消息摘要，A 通过 b-public-key 解密收到这个加密后的消息摘要，并还原成随机消息来比较他之前发送给 B 的rand-msg。

 

      ~~~个人感觉，这里主要多了一个对消息进一步的消息摘要的构造过程。多了一层保护，因为一般是不知道如何构造摘要的。

 

      而这个改进技术就是数字签名技术。正如我个人感觉的这里的消息摘要（签名）只是多了一层消息的构造过程，同样有些危险。因此，我们的认证协议需要一次以上的协议（来保证更安全的保护），让部分（or全部）的数据由B 来产生（好像也更人性化了一点:P）：

 

      A-->B        Hello, are you B ?
      B-->A        A, This is B!{Digest[A, This is B!]}b-private-key

 

      此处，我们可以看到了变化：

 

      * B发送了自己想要发送的消息摘要

      *多了发送的另一部分经过 b-private-key 加密的消息摘要，这个主要用于让 A 来验证 B 是否就是真的B，感觉充分使用了这个别人不知道的 b-private-key :P

 

 ====> 证书
     
      上面我们提到过，在一开始B “偷偷的” 发送了一个 public-key 给 A（否则任何人都可以是 B了），为了解决这个问题，标准化组织发明了一个叫做证书的咚咚，一个证书主要包含如下信息：

 

　　* 证书的发行者姓名
　　
　　* 发行证书的组织
　　
　　* 标题（主题）的公钥
　　
　　* 邮戳

 

      证书使用发行者（这里如 B ）的私钥加密。每一个人（如 A）都知道证书发行者的公钥（这样，每个证书的发行者拥有一个证书）。证书是一个把公钥与（证书的发行者）姓名绑定的协议。通过使用证书技术，每一个人（如A ）都可以检查 B 的证书，判断是否被假冒。假设 B 控制好他的私钥，并且他确实是得到证书的 B，就万事大吉了。

 

　　1，A-->B      hello
　　2，B-->A      Hi, 兄弟，我是 B, 看，这是我的证书 b-certificate
　　3，A-->B      别以为你有了 B 的证书 b-certificate，我就真的以为你是 B 了，证明你是 B
　　4，B-->A      A, This Is B{Digest[A, This Is B]}b-private-key       

 

      再次解释一下：当 A 收到 B 的第一条消息（2步）后，他可以检查并核实证书，以及签名（如上，使用了消息摘要和公钥加密），然后再核实主题（B 的名字）来确定是不是真的 B。这样，A就可以确信这个公钥的确是 B 的公钥，下面，再次要求 B 证明他的身份。B 则重新进行如上的过程，计算消息摘要，然后使用private-key 进行加密... ...

 

      *不是有了证书，你就可以进 A 的家门的

      * 因为你没有 B的私钥，所以你无法构造一个可以让 A 相信这是来自 B 的消息。
     
 ====>交流秘密
     
      下面终于可以进入 A的家门了，B 好辛苦啊，但是下面的交流还是秘密啊，不能被旁人看到，那可是国家机密哦:)
     
      当然，A之后发送的消息就是只有 B 才能解码的消息了，如下：

 

      *A-->B        {secret} b-public-key

 

      分析一下上面这个 secret，发现这个 secret 的方法只有使用 B 的私钥 b-private-key来解密，交换秘密是公用密钥密码系统的另一种强大的用法。即使 A 和 B 之间的通信被监视，除了 B，也没有人能够得到秘密。

 

      因为A（这是他自己传送的秘密） 和 B（他有私钥）都知道这个秘密，所以他们就可以初始化一个对称的密码算法（如DES，RC4，IDEA），然后开始传输用它加密的消息。下面是修正后的协议：

 

　　A --> B hello
　　B --> A Hi, I'm B, b-certificate
　　A --> B prove it
　　B --> A A, This Is b{ digest[A, This Is B] }b-private-key
　　A --> B ok b, here is a secret {secret}b-public-key              // A 传了一个 secret
　　B --> A {some message}secret-key

 

      其中，secret-key 的计算取决于协议的定义，但是它可以简化成一个 secret 的副本。

 

 ===> Hacker 来袭

 

      有些Hacker 很坏，他们虽然不能 “窃听” 到 A 和 B 之间的国家级机密的对话，但是他们可以从中作梗：

 

　　A-->M hello
　　M-->B hello
　　
　　B-->M Hi, I'm B, B-certificate
　　M-->A Hi, I'm B, B-certificate
　　
　　A-->M prove it
　　M-->B prove it
　　
　　B-->M A, This Is B{ digest[A, This Is B] }B-private-key
　　M-->A A, This Is B{ digest[A, This Is B] }B-private-key
　　
　　A-->M ok B, here is a secret {secret}B-public-key
　　M-->B ok B, here is a secret {secret}B-public-key
　　
　　B-->M {最近国际形势不太乐观啊！}secret-key
　　M-->A Garble[ {最近国际形势不太乐观啊！}secret-key ] // 如果 M 够“幸运” 的话，可能变成了 “你这个大笨蛋！”
     
      可以看到这个Hacker 好坏，他一直等到 A 和 B 开始交流机密了，然后通过改变 B 发送给 A 的机密的方式开始作梗，而此时 A已经相信这是 B 的机密了（可能变成了: 你这个大笨蛋！:P ），结果悲剧再一次上演... ...

 

      为了防止这种破坏，A 和 B 在他们的协议中引入了一种消息认证码（Message Authentication Code,MAC）。MAC 是根据秘密的密钥和传输的数据计算出来的，上面描述的消息摘要算法的属性正好可以用于构造抵抗 M的MAC功能。

 

      MAC :=Digest[ some message, secret ]

 

      注：我们发现之前的消息摘要只是对消息进行构造，此处，包括了 secret。

 

      因为 M不知道这个秘密的密钥，所以他无法计算出这个摘要的正确数值。即使 M随机的改变消息，如果摘要数据很大的话，他成功的可能性也会很小。例如，通过使用 MD5（RSA公司发明的一种很好的密码摘要算法），A 和B 能和他们的消息一起发送 128 位的 MAC 值。M 猜中这个正确的 MAC 值的几率只有1/18,446,744,073,709,551,616。

 

      下面是又一次的修正协议：

 

      A--> B 你好
      B--> A 嗨，我是 B，b-certificate
      A--> B prove it
      B--> A {digest[A, 我是 B] } b-private-key
      A--> B ok B, here is a secret{secret}b-public-key
      B--> A {some message，MAC}secret-key

 

      现在 M已经无技可施了。他如果下面想要干扰了得到的消息，A 和 B 能够发现伪造的 MAC 值并且立即停止交谈。这样 M 不再能与 B通讯。
     

整个过程：

 

      1，分发证书

      2，验证证书，验证身份

      3，交换秘密