基本加密协议：密钥交换
5.00/5 (7投票s)
安全通信信道中管理密钥交换的协议简介。
引言
密钥交换是一项必要的操作，旨在为网络中的两个或多个用户获取一个安全通道。由于安全性通常是通过加密在不受信通道上传输的数据来获得的，因此用于以有意义的方式加密/解密这些数据的密钥必须在通道用户之间共享。这一步骤在常见的加密操作中始终存在，并且通常是会话建立的一部分。希望在彼此之间交换安全数据的两个用户，Alice 和 Bob，需要就用于保护数据的密码和密钥达成一致。
在本文中，我将介绍用于此操作的基本和常用协议。请注意，单独使用某些给定的协议不足以在所需连接上获得安全性。后续文章将介绍其他功能，如身份验证、签名和数字身份。
本文开头提供了一组小而独立的原型可供下载。这些实用程序让您可以亲手实践后续章节中介绍的概念。
背景
读者应具备关于 C 编程语言、GCC 构建工具链、网络和套接字编程以及 Linux 操作系统的良好知识。不必熟悉 OpenSSL 和 Libcrypto，因为我们将在介绍源代码的同时，引入一个介于原型和此库之间的包装器。
我还热烈建议阅读 Bruce Schneier 的教科书《应用密码学：C 语言的协议、算法和源代码》（Applied Cryptography: Protocols, Algorithms, and Source Code in C），因为它被用作开发代码的主要信息来源，并作为撰写本文的指南。此外，互联网上提供了大量易于获取的关于此类主题的资源（通常更新），您只需搜索即可。
加密包装器
通常，软件工程师希望在自己与现实（或问题）之间尽可能多地插入抽象层。为了保护自己免受特定加密库实现的影响，我引入了这个小型包装器，它将为我提供一个隐藏所有细节的简单 API。该包装器目前仅在 Linux 上的 OpenSSL 基础库 libcrypto 上工作，但我会保持其足够的灵活性，以便将来扩展到其他一些库（谁知道呢）。
此类软件的设计旨在保持类 Unix API 的简单性，同时仍试图提供尽可能多的灵活性和功能。除此之外，该包装器被设计为主要操作 OpenSSL 的底层功能，因此协议的设计取决于您。您将不会找到一个能从头开始做所有事情的魔法般的“EstablishSession”过程，而是需要为您需要执行的加密功能设计交互和状态机（不允许懒惰的程序员）。
目前 API 非常小。以下例程允许开发人员为将来使用保留一个加密描述符。该描述符将通过返回的整数标识符进行访问。
/* Close a previously open descriptor */
void CryptClose(int cd);
/* Open a new unused cryptographic descriptor.
* Returns a valid descriptor, or a negative error code.
*/
int CryptOpen();
描述符的数量限制为 CRYPTO_HANDLES_MAX，这应在编译时提供。尝试分配超过此数量将导致包装器生成一个错误（负值）。处于“打开”状态的描述符不可用，必须进行初始化才能执行任何可用的特定加密操作。
/* Setup a cryptographic descriptor to operate with AES mode.
* Returns 0 on success, otherwise a negative error code.
*/
int CryptAES(int cd, int bits, unsigned char * key, unsigned char * iv, int flags);
/* Setup a cryptographic descriptor to operate with RSA mode.
* Returns 0 on success, otherwise a negative error code.
*/
int CryptRSA(int cd, char * key, int len, int flags);
目前仅提供 AES CBC 和 RSA 密码，为软件使用的加密技术提供对称和非对称密码。希望将来会有新的模式可用。
一旦描述符以其专门模式初始化，您需要做的就是用给定的数据执行加密/解密。要执行此类操作，请使用以下过程
/* Use the given cryptographic descriptor to decrypt data.
* Returns the length of the recovered data, or a negative error code.
*/
int Decrypt(
int cd,
char * plain,
unsigned int plen,
char * cipher,
unsigned int clen);
/* Use the given cryptographic descriptor to encrypt data.
* Returns the length of the encrypted data, or a negative error code.
*/
int Encrypt(
int cd,
char * plain,
unsigned int plen,
char * cipher,
unsigned int clen);
API 提供的所有公共过程都是线程安全的，这意味着抽象层将在不同上下文之间保持同步（使用 pthread 互斥锁进行描述符分配和加密/解密过程）。
警告：此包装器处于绝对的 Alpha 状态，我不建议您在除了这个小型“加密实验室”之外的任何其他项目中使用它。随着未来文章中引入其他主题，您将看到包装器的形态不断演变以适应越来越多的需求。
命名约定
本文将采用以下命名/风格约定
- Alice、Bob 和 Carol 将是希望以安全方式交换数据的用户。
- Eve 将是服务提供商的名称，并将对用户之间交换的数据进行窃听。
- Mallory 将是试图对合法用户之间交换的流量进行某些篡改的服务提供商。
- Trent 将扮演所有网络用户都信任的权威角色。
- 明文消息将由变量 m 表示。
- 加密消息将由变量 c 表示。
- 使用例如 Alice 的密钥对消息进行的对称加密将写为
- 使用例如 Alice 的密钥对密文进行的对称解密将写为
- 在非对称密码的情况下，加密和解密将指定使用用户的公钥（P，大写）或私钥（p，小写），如下所示
, 
使用对称密码的密钥交换
对称密码的工作原理是使用相同的密钥来加密和解密消息。这意味着安全通道的用户必须拥有相同的密钥，才能以所有用户都能理解的方式进行读写。对于密钥交换问题，您需要将此密钥从 Alice 移动到 Bob，而不能让任何中间窃听者获取该密钥。
要使此协议生效，需要一个受信任的第三方用户 Trent，他将充当会话创建者的中介。Alice 和 Bob 已经有一个用于保护他们与 Trent 之间秘密的密钥。我假设该密钥已经通过手动或其他常规渠道秘密提供。
使用对称密钥的协议工作方式如下
- Alice 使用 Alice-Trent 密钥联系 Trent，并请求与 Bob 建立会话。
- Trent 准备一个会话密钥，并使用 Bob-Trent 密钥对其进行加密。然后它将其附加（连接）到明文会话密钥上，并用 Alice-Trent 密钥加密所有内容，然后将所有内容发送给她。
- Alice 解密 Trent 发送给她的任何内容。此信息包含 Alice-Bob 会话密钥和一个 Alice 无法解密（因此也无法更改）的加密部分。
- Alice 将这最后一部分（她无法读取的）发送给 Bob。
- Bob 收到消息并使用 Bob-Trent 密钥解密，该密钥是这些用户之间的私有密钥，其他人不知道。解密后的消息将包含 Alice 收到的相同会话密钥。
- Alice 和 Bob 开始使用新获得的会话密钥进行通信。
此协议依赖于 Trent 的可用性和对他的信任。如果 Trent 服务器因任何原因无法访问，通信将无法进行，因为无法在 Alice 和 Bob 之间创建会话密钥。整个架构高度集中于 Trent 的服务以及使用只有 Alice/Bob 和受信任用户知道的唯一密钥的能力。
多用户对称密码密钥交换
该协议可以扩展到两个以上的用户；需要做的是指示 Alice 将正确的加密部分分派给正确的用户。请注意，在这种情况下，Eve 无法知道正在交换何种信息，但可以通过查看未知消息的目标名称直接知道谁将是此次对话的参与者。
这应该如下工作
- Alice 向 Trent 请求与 Bob 和 Carol 建立会话。
- Trent 为每个参与者创建一份会话密钥的副本，并使用只有参与者和他自己知道的私钥加密每个副本。这意味着消息将按以下格式组织
- Alice 解密消息，从而发现将用于通信的会话密钥。然后她继续将那些为她保留且不可读的部分发送到各自的目的地。
- Bob 和 Carol 将收到一条用只有他们和 Trent 知道的密钥加密的消息，并将使用该密钥来揭示会话密钥。
或者，Alice 可以将整个加密部分发送给“链”中的下一个元素，后者将解密其部分并再次将所有内容发送给下一个元素。此操作一直进行到最后一个元素获取密钥并发送信号通知链中的每个人都已准备就绪。此操作并不能真正隐藏谁将成为此对话的成员，但一旦用户同时进行多个通信通道，就更难追踪。更不用说控制不同主机之间的通信比控制单个主机的通信要困难得多，因此仅查看 Alice 的流量在这种情况下无助于识别每个人。
- Alice 向 Trent 请求与 Bob 和 Carol 建立会话。
- Trent 为每个参与者创建一份会话密钥的副本，并按“链”的相反顺序加密密钥。这意味着消息将按以下格式组织
- Alice 收到消息，解密它并发现会话密钥。
然后将不可读的部分发送给 Bob。
- Bob 收到消息，解密它并发现会话密钥。
然后将不可读的部分发送给 Carol。
- Carol 收到消息，解密它并发现会话密钥。现在消息末尾没有更多要发送的数据，因此她使用会话密钥向 Bob 报告，她已准备好开始会话交互。
- 此反馈沿链向后传递，直到 Alice 收到反馈并最终开始与其他节点通信。
这种多用户、链式对称密钥交换的最后一种扩展在像洋葱网络这样的系统中可能有些用处，其中通信会话需要在定义电路中的多个节点之间建立。在这种情况下，Alice 是会话发起者，而链是应该交换会话密钥以能够执行数据加密/解密的电路。
对称加密示例
您可以通过在根目录调用 make 来构建整个项目，或者分别构建单个实验。将目录更改为 Basic/KeyExchange/Symmetric 以访问对称密钥交换软件。准备四个控制台，以便每个控制台运行一个用户，然后从 Eve 开始（否则其他用户无法相互通信）。
第二个要运行的用户必须是 Trent，因为他是这个小网络的受信任节点。如果成功启动，控制台将报告以下反馈
Basic Cryptography: Symmetric Key exchange
Setting up cryptographic contexts...
1/2 Initializing Alice context............DONE
2/2 Initializing Bob context..............DONE
Initializing network..........................DONE
Presenting to network provider................DONE
您还会注意到 Eve 将会知道他在网络中的存在。
第三步是运行 Bob，因为他将 passively 等待 Alice 用他和 Trent 的秘密密钥加密的会话密钥与他交换。如果成功启动，控制台将报告以下反馈
Basic Cryptography: Symmetric Key exchange
Preparing Cryptographic contexts...
1/2 Preparing Bob-Trent context...........DONE
2/2 Preparing Alice-Bob context...........DONE
Initializing network..........................DONE
Presenting to network provider................DONE
同样，此时 Eve 也会知道 Bob 在网络中的存在。
最后一步是在另一个控制台中运行 Alice。如果成功启动，控制台将报告以下反馈
Basic Cryptography: Symmetric Key exchange
Preparing Cryptographic contexts...
1/2 Preparing Alice-Trent context.........DONE
2/2 Preparing Alice-Bob context...........DONE
Initializing network..........................DONE
Presenting to network provider................DONE
Requesting session key to Trent...............DONE
Decrypting arrived message....................DONE
Alice-Bob session key: 51 bf 5f c1 27 78 d0 1a 42 80 66 86 e4 5d c8 d2 03 be 91 5f 7a 2a d1 e3 1b c4 7d 78 dd df e7 2f
Input vector: 9e 47 f0 c6 bf c0 e0 01 40 46 87 24 a3 4f f6 a6
Preparing Alice-Bob session...................DONE
Sending session information to Bob............DONE
Secret messages from Bob:
Hello Alice, this is Bob!
Terminating...
此时 Eve 将会知道 Alice 在网络中的存在。除此之外，您还将在 Eve 的控制台中看到 Alice 请求与 Bob 建立会话的消息
Received 2 bytes --> ToTrent
00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
000 00 00
Trent 对此空消息做出反应，生成会话密钥并以加密形式发送给 Alice。这在 Eve 的控制台中留下了以下痕迹
Received 128 bytes --> ToAlice
00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
000 56 0f 07 6b a3 6c e7 94 89 6c 83 db b2 e9 e5 72
010 25 22 50 9e 0a 30 d2 cf f8 28 47 22 ab 85 e4 7c
020 1f 19 c0 c8 97 4f 85 f6 11 23 6b e4 50 b8 94 c7
030 dc c0 1a 3c a9 23 c9 09 50 cc 6f aa d8 12 5e 3b
040 85 23 d2 57 fd ca ae 13 88 26 b0 66 55 b9 fc 0c
050 9f 36 35 5c 39 4e c2 bd ae e7 ec b0 85 a8 42 b7
060 58 96 b4 b9 6b 53 c9 a6 8f 09 55 87 19 df 6c 70
070 5d 93 61 02 44 5a dd 5f d5 a5 62 1d cb 53 8f 49
如您所见，现在消息是加密的（例如，消息的大小不是 32（密钥）+16（IV）字节，而是对齐的 AES-256 输出块）。您将无法在任何地方以明文格式看到会话信息。
Alice 接着解密收到的消息，并提取会话信息。现在轮到她向 Bob 发送会话详情了，这些详情对她来说仍然是不可读的（但她仍然可以推测它们是相同的）。这在 Eve 中留下了以下痕迹
Received 64 bytes --> ToBob
00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
000 a9 ee a4 8c 00 f3 7e c2 45 3d 03 b5 1c d4 aa 98
010 78 3e 7e 4d 2d 0f 67 33 8c b8 f8 34 f1 4b 1a 10
020 80 2c ec da 05 40 47 21 4a a0 0e d8 f4 03 2a 80
030 75 10 66 1b 37 21 3e da ff b2 68 3e 5c 9c 9c 15
Bob 的软件然后解密消息，提取会话密钥并用它们向 Alice 发送一个加密的 Hello。这在 Eve 的控制台中留下了以下最终痕迹
Received 32 bytes --> ToAlice
00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
000 23 72 c6 ac dd 11 7b 92 36 88 ee 2a 29 a0 2b 12
010 4f f5 c6 d5 b2 53 44 19 eb 03 f6 94 a0 70 a4 a4
使用非对称密码的密钥交换
非对称密码与对称密码的不同之处在于用于加密和解密的密钥数量。非对称密码密钥成对出现：其中一个密钥（公钥）用于加密消息，另一个密钥（私钥）用于解密。用一个密钥加密的信息在没有另一个密钥的情况下是无法（在合理的时间内，用合理的资源）解密的。
生成一对非对称密钥的用户通常希望发布其公钥，同时保密另一个密钥。
密钥交换协议的行为如下
- Alice 生成一对非对称密钥，一个是私有的，另一个是公共的。
然后她按原样与 Bob 共享密钥。
- Bob 生成一对非对称密钥，一个是私有的，另一个是公共的。
当他收到 Alice 的公钥时，他将用自己的公钥回应。
- 使用 Bob 的公钥，Alice 就可以开始与他通信，反之亦然。
- 然后 Bob 使用自己的私钥解密消息。
如您所见，现在协议变得简单得多，密钥交换在没有任何中间角色的情况下发生。但这有代价。首先，非对称密码操作更昂贵，加密/解密消息变得更慢。其次，在没有任何额外安全措施的情况下使用，这个初始消息交换容易受到中间人攻击（我们将在下一章看到）。
非对称加密示例
与对称示例一样，您可以从根目录一起构建此项目，或通过移动到文件夹 Basic/KeyExchange/Asymmetric 并在那里调用 make 来构建。构建过程将为 Alice 和 Bob 准备公钥和私钥（如果尚未生成），然后继续构建 Alice、Bob 和 Eve 的应用程序。
同样，首先启动 Eve 以允许 Alice 和 Bob 的通信发生。在 Eve 之后，您可以在另一个控制台中运行 Bob；他的终端上可见的反馈将是
Basic Cryptography: Asymmetric Key exchange
Setting up cryptographic contexts...
1/2 Loading private key...................DONE
2/2 Loading public key....................DONE
Initializing network..........................DONE
Presenting to network provider................DONE
应用程序将开始等待 Alice 的反馈。从现在开始，Eve 将能够将消息转发给 Bob，因为他已经注册了网络服务。此时 Eve 控制台上的痕迹是
Received 0 bytes --> Bob
00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
000
Bob on port 53911
现在在另一个控制台上运行 Alice。这将在她的控制台上生成以下输出
Basic Cryptography: Asymmetric Key exchange
Setting up cryptographic contexts...
1/2 Loading private key...................DONE
2/2 Loading public key....................DONE
Initializing network..........................DONE
Presenting to network provider................DONE
Preparing Bob context...
1/3 Requesting Bob public key.............DONE
2/3 Receiving the key.....................DONE
3/3 Preparing Bob context.................DONE
Key received from Bob:
00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
000 2d 2d 2d 2d 2d 42 45 47 49 4e 20 50 55 42 4c 49
010 43 20 4b 45 59 2d 2d 2d 2d 2d 0a 4d 49 49 42 49
020 6a 41 4e 42 67 6b 71 68 6b 69 47 39 77 30 42 41
030 51 45 46 41 41 4f 43 41 51 38 41 4d 49 49 42 43
040 67 4b 43 41 51 45 41 79 62 4a 6c 6d 62 51 64 71
050 6d 4e 62 45 4a 6e 37 57 67 6c 5a 0a 4b 53 52 6a
060 58 51 36 77 47 43 76 74 50 69 6c 48 65 32 2f 6f
070 71 70 54 38 50 36 53 4d 50 79 42 48 68 47 69 67
080 6b 70 75 45 48 34 50 34 65 35 36 72 74 66 2f 51
090 73 75 5a 70 57 68 79 63 64 49 65 61 0a 6f 69 73
0a0 58 64 63 69 56 33 66 46 6d 4a 56 38 45 6c 33 65
0b0 70 57 75 77 64 4f 41 66 79 70 54 4d 42 69 71 70
0c0 38 6d 32 64 6b 41 51 70 57 63 36 66 5a 55 57 53
0d0 59 54 6c 36 39 5a 6a 48 56 39 39 55 56 0a 35 6d
0e0 4c 4f 55 30 4a 46 50 59 44 71 6c 4c 70 74 55 59
0f0 4c 38 4f 53 33 48 51 6e 4f 4f 56 6d 64 6d 65 4a
100 2b 34 68 50 72 31 39 55 48 6f 39 66 64 33 39 2f
110 76 74 62 6a 7a 4a 33 35 47 61 42 70 39 62 0a 47
120 64 71 6a 49 57 49 57 33 68 4e 72 6e 64 4e 79 61
130 4d 6f 65 72 63 51 57 32 42 32 49 30 34 65 52 73
140 65 79 79 41 75 6b 6c 55 31 35 64 33 37 55 73 36
150 56 71 6f 43 32 6c 70 47 41 67 68 32 4f 47 54 0a
160 70 75 65 70 42 34 5a 5a 47 66 30 4b 6f 4b 57 76
170 59 70 35 38 7a 78 33 4a 49 75 67 43 64 46 54 76
180 4d 5a 55 4a 41 64 52 46 58 37 63 67 44 53 4d 72
190 38 63 78 64 58 45 4b 46 77 73 32 46 6f 58 48 2f
1a0 0a 72 51 49 44 41 51 41 42 0a 2d 2d 2d 2d 2d 45
1b0 4e 44 20 50 55 42 4c 49 43 20 4b 45 59 2d 2d 2d
1c0 2d 2d 0a
Sending private message to Bob: "Hey Bob!"
Terminating...
Alice 将订阅 Eve 的网络服务，然后立即将她的公钥发送给 Bob。此操作后，她将收到 Bob 的公钥，该公钥将用于使用收到的密钥初始化另一个用于公钥加密的加密描述符。此步骤之后，一条简单的消息被加密并使用 Eve 分派给 Bob。
现在，此时 Eve 控制台上的输出是
Received 0 bytes --> Alice
00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
000
Alice on port 61430
Received 451 bytes --> ToBob
00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
000 2d 2d 2d 2d 2d 42 45 47 49 4e 20 50 55 42 4c 49
010 43 20 4b 45 59 2d 2d 2d 2d 2d 0a 4d 49 49 42 49
020 6a 41 4e 42 67 6b 71 68 6b 69 47 39 77 30 42 41
030 51 45 46 41 41 4f 43 41 51 38 41 4d 49 49 42 43
040 67 4b 43 41 51 45 41 35 36 6b 6f 37 36 44 4c 75
050 35 46 55 36 56 52 64 51 42 56 78 0a 64 4f 58 50
060 63 6e 36 79 31 4d 6e 2b 63 4f 47 75 4e 48 65 79
070 76 36 39 38 2b 2b 33 4b 42 7a 58 77 47 57 48 6d
080 77 73 62 75 71 56 51 6b 2b 77 58 33 33 48 55 32
090 56 38 61 63 76 4b 53 6b 2f 78 48 63 0a 68 6b 79
0a0 72 70 59 66 53 6b 78 6a 41 70 6a 47 6c 51 46 70
0b0 31 31 6c 4e 4a 39 7a 37 6b 34 6d 47 72 59 5a 74
0c0 78 2f 70 45 32 79 47 70 74 65 6f 69 78 6e 72 49
0d0 51 6f 52 52 58 77 69 6b 54 74 69 65 4b 0a 79 2f
0e0 42 50 6e 63 67 79 30 42 53 47 55 67 4a 67 37 43
0f0 68 76 66 4d 65 43 57 36 52 4e 50 62 4e 55 41 67
100 48 31 38 75 45 74 42 58 4e 75 63 49 4a 56 58 48
110 44 76 79 6d 66 70 58 47 36 69 34 43 72 39 0a 4a
120 6e 41 46 75 48 41 42 63 6e 75 35 6a 75 4e 37 61
130 58 31 77 4d 69 4b 76 77 58 4f 4c 63 41 56 39 79
140 33 33 32 34 54 69 70 4b 79 66 62 50 67 71 39 73
150 59 6f 67 69 2b 6d 42 71 6b 73 5a 6f 78 65 46 0a
160 2f 6f 47 47 67 32 52 4e 48 59 69 4f 37 4c 51 47
170 77 51 65 66 57 45 62 64 6b 6f 4b 4d 65 4f 75 2b
180 48 58 71 70 4b 63 6c 46 5a 72 52 35 6e 52 4c 6a
190 39 71 59 58 6a 72 47 2f 36 4f 53 6a 59 51 66 56
1a0 0a 57 51 49 44 41 51 41 42 0a 2d 2d 2d 2d 2d 45
1b0 4e 44 20 50 55 42 4c 49 43 20 4b 45 59 2d 2d 2d
1c0 2d 2d 0a
Received 451 bytes --> ToAlice
00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
000 2d 2d 2d 2d 2d 42 45 47 49 4e 20 50 55 42 4c 49
010 43 20 4b 45 59 2d 2d 2d 2d 2d 0a 4d 49 49 42 49
020 6a 41 4e 42 67 6b 71 68 6b 69 47 39 77 30 42 41
030 51 45 46 41 41 4f 43 41 51 38 41 4d 49 49 42 43
040 67 4b 43 41 51 45 41 79 62 4a 6c 6d 62 51 64 71
050 6d 4e 62 45 4a 6e 37 57 67 6c 5a 0a 4b 53 52 6a
060 58 51 36 77 47 43 76 74 50 69 6c 48 65 32 2f 6f
070 71 70 54 38 50 36 53 4d 50 79 42 48 68 47 69 67
080 6b 70 75 45 48 34 50 34 65 35 36 72 74 66 2f 51
090 73 75 5a 70 57 68 79 63 64 49 65 61 0a 6f 69 73
0a0 58 64 63 69 56 33 66 46 6d 4a 56 38 45 6c 33 65
0b0 70 57 75 77 64 4f 41 66 79 70 54 4d 42 69 71 70
0c0 38 6d 32 64 6b 41 51 70 57 63 36 66 5a 55 57 53
0d0 59 54 6c 36 39 5a 6a 48 56 39 39 55 56 0a 35 6d
0e0 4c 4f 55 30 4a 46 50 59 44 71 6c 4c 70 74 55 59
0f0 4c 38 4f 53 33 48 51 6e 4f 4f 56 6d 64 6d 65 4a
100 2b 34 68 50 72 31 39 55 48 6f 39 66 64 33 39 2f
110 76 74 62 6a 7a 4a 33 35 47 61 42 70 39 62 0a 47
120 64 71 6a 49 57 49 57 33 68 4e 72 6e 64 4e 79 61
130 4d 6f 65 72 63 51 57 32 42 32 49 30 34 65 52 73
140 65 79 79 41 75 6b 6c 55 31 35 64 33 37 55 73 36
150 56 71 6f 43 32 6c 70 47 41 67 68 32 4f 47 54 0a
160 70 75 65 70 42 34 5a 5a 47 66 30 4b 6f 4b 57 76
170 59 70 35 38 7a 78 33 4a 49 75 67 43 64 46 54 76
180 4d 5a 55 4a 41 64 52 46 58 37 63 67 44 53 4d 72
190 38 63 78 64 58 45 4b 46 77 73 32 46 6f 58 48 2f
1a0 0a 72 51 49 44 41 51 41 42 0a 2d 2d 2d 2d 2d 45
1b0 4e 44 20 50 55 42 4c 49 43 20 4b 45 59 2d 2d 2d
1c0 2d 2d 0a
Received 256 bytes --> ToBob
00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
000 66 01 3a 04 35 a1 87 4b 13 a0 92 61 4b 5c ae bc
010 a7 fe fc ed f5 03 a1 50 ef c1 3e aa a7 65 cf 70
020 77 7a 1e da 62 cb ce 47 86 fb 90 62 9e 4f 99 d9
030 03 53 b3 9d e9 bb 48 28 57 ab 2d 4b c3 58 3e 7c
040 27 ed 15 e3 a3 6c 29 52 d0 4f 86 e0 18 28 77 d5
050 0c 6e d7 80 e5 80 28 e7 b2 0e 57 8d 2a 44 94 84
060 83 c2 80 7f 17 97 b1 ec 85 e4 22 e0 69 b1 b1 e3
070 75 8c b0 56 81 96 90 c6 7e b6 77 50 e8 09 e3 d1
080 32 31 a1 ad 33 d8 e9 e8 21 60 ac ee d7 96 eb 2a
090 7f 80 6c 93 fe 89 91 a4 f2 82 c3 21 43 cf 36 e5
0a0 46 7a 30 e7 83 1f bf 13 ad 5e ff b0 19 16 25 87
0b0 da 11 11 03 13 47 e5 b5 43 bd 79 2f 61 96 f2 a3
0c0 a6 86 ff ed 22 a0 a7 ce eb d8 61 3d 7a 46 b0 a3
0d0 9b 07 ac 67 d8 d5 bc 5e 85 49 04 fa d1 6e f4 15
0e0 73 be a2 1c 31 8f ce 3e e4 2f f1 f0 73 48 67 b9
0f0 3c ea eb dd 68 0e d8 89 6d 74 1d 46 12 16 b9 14
第一条消息是 Alice 向 Eve 服务进行介绍，接下来的两条消息包含 Alice 和 Bob 交换的公钥（PEM 格式密钥文件的 451 字节）。最后一条消息是包含 Alice 的 hello 的 2048 位加密字节块。
Bob 的控制台将以以下输出终止
Waiting for Alice message.....................DONE
Message is: Hey, Bob!
Terminating...
针对非对称密码密钥交换的中间人攻击
正如您可能在上一章中已经意识到的那样，虽然协议已经简化并且现在很直接，但它极易受到中间人攻击。这种类型的攻击通常看到一个节点在通信中间伪装成一个或另一个用户的角色，以便解密并最终更改正在经过的流量。
这里的攻击遵循以下步骤
- Alice 生成一对非对称密钥，一个是私有的，另一个是公共的。
然后她按原样与 Bob 共享密钥。
- Mallory 拦截密钥并保存以备后用。然后向 Bob 发送一个模仿合法 Alice 公钥的假公钥。
- Bob 生成一对非对称密钥，一个是私有的，另一个是公共的。
当他收到 Alice 的假公钥时，他会用自己的公钥回应。
- Mallory 再次拦截密钥并保存以备后用。然后向 Alice 发送一个模仿合法 Bob 公钥的假公钥。
- Alice 使用她认为是来自 Bob 的密钥加密给 Bob 的私密消息。
操作完成后，她将其发送给 Bob。
- Mallory 现在使用 Bob 的假私钥解密所有内容，打印消息，然后使用真实的 Bob 公钥对其进行加密。然后将用合法密钥加密的消息发送给 Bob。
- Bob 解密消息，但没有意识到它已被拦截和解密。甚至 Alice 也没有意识到中间有攻击者干扰了通信。Mallory 本可以更改消息的顺序/请求，而通信的任何一方都没有意识到他们已被拦截。
这并不意味着使用非对称密码进行密钥交换是不安全的，而是意味着需要一些额外的机制（如身份验证，即将推出）来正确执行操作，或者至少检测篡改。
中间人攻击示例
再次切换文件夹以匹配 Basic/KeyExchange/MITM。在此目录中，您会找到使用非对称密码的 Bob 和 Alice 应用程序的副本。对于这两个用户来说，没有任何改变，因为这种攻击对于协议交互是完全透明的。在此示例中，我们将只关注 Mallory 的控制台，因为 Alice 和 Bob 的控制台与之前的没有任何区别。
如果您启动 Mallory，您将看到以下内容
Creating cryptographic contexts...
1/4 Loading fake Alice private key........DONE
2/4 Loading fake Alice public key.........DONE
3/4 Loading fake Bob private key..........DONE
4/4 Loading fake Bob public key...........DONE
该应用程序期望 Alice 和 Bob 连接，因此准备了一对私钥/公钥，将用于交换合法密钥。然后它等待 Bob 和 Alice 上线。Bob 的启动不会触发任何事情，因为将是 Alice 开始通信和公钥交换。
一旦 Alice 运行，Mallory 的控制台将追踪公钥交换，提供假的密钥，并将使用假密钥的加密转换为使用合法密钥的加密。操作结束时，他的控制台将显示以下文本
Received 0 bytes --> Bob
00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
000
Bob on port 50600
Received 0 bytes --> Alice
00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
000
Alice on port 50601
Received 451 bytes --> ToBob
00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
000 2d 2d 2d 2d 2d 42 45 47 49 4e 20 50 55 42 4c 49
010 43 20 4b 45 59 2d 2d 2d 2d 2d 0a 4d 49 49 42 49
020 6a 41 4e 42 67 6b 71 68 6b 69 47 39 77 30 42 41
030 51 45 46 41 41 4f 43 41 51 38 41 4d 49 49 42 43
040 67 4b 43 41 51 45 41 35 36 6b 6f 37 36 44 4c 75
050 35 46 55 36 56 52 64 51 42 56 78 0a 64 4f 58 50
060 63 6e 36 79 31 4d 6e 2b 63 4f 47 75 4e 48 65 79
070 76 36 39 38 2b 2b 33 4b 42 7a 58 77 47 57 48 6d
080 77 73 62 75 71 56 51 6b 2b 77 58 33 33 48 55 32
090 56 38 61 63 76 4b 53 6b 2f 78 48 63 0a 68 6b 79
0a0 72 70 59 66 53 6b 78 6a 41 70 6a 47 6c 51 46 70
0b0 31 31 6c 4e 4a 39 7a 37 6b 34 6d 47 72 59 5a 74
0c0 78 2f 70 45 32 79 47 70 74 65 6f 69 78 6e 72 49
0d0 51 6f 52 52 58 77 69 6b 54 74 69 65 4b 0a 79 2f
0e0 42 50 6e 63 67 79 30 42 53 47 55 67 4a 67 37 43
0f0 68 76 66 4d 65 43 57 36 52 4e 50 62 4e 55 41 67
100 48 31 38 75 45 74 42 58 4e 75 63 49 4a 56 58 48
110 44 76 79 6d 66 70 58 47 36 69 34 43 72 39 0a 4a
120 6e 41 46 75 48 41 42 63 6e 75 35 6a 75 4e 37 61
130 58 31 77 4d 69 4b 76 77 58 4f 4c 63 41 56 39 79
140 33 33 32 34 54 69 70 4b 79 66 62 50 67 71 39 73
150 59 6f 67 69 2b 6d 42 71 6b 73 5a 6f 78 65 46 0a
160 2f 6f 47 47 67 32 52 4e 48 59 69 4f 37 4c 51 47
170 77 51 65 66 57 45 62 64 6b 6f 4b 4d 65 4f 75 2b
180 48 58 71 70 4b 63 6c 46 5a 72 52 35 6e 52 4c 6a
190 39 71 59 58 6a 72 47 2f 36 4f 53 6a 59 51 66 56
1a0 0a 57 51 49 44 41 51 41 42 0a 2d 2d 2d 2d 2d 45
1b0 4e 44 20 50 55 42 4c 49 43 20 4b 45 59 2d 2d 2d
1c0 2d 2d 0a
Received 451 bytes --> ToAlice
00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
000 2d 2d 2d 2d 2d 42 45 47 49 4e 20 50 55 42 4c 49
010 43 20 4b 45 59 2d 2d 2d 2d 2d 0a 4d 49 49 42 49
020 6a 41 4e 42 67 6b 71 68 6b 69 47 39 77 30 42 41
030 51 45 46 41 41 4f 43 41 51 38 41 4d 49 49 42 43
040 67 4b 43 41 51 45 41 79 62 4a 6c 6d 62 51 64 71
050 6d 4e 62 45 4a 6e 37 57 67 6c 5a 0a 4b 53 52 6a
060 58 51 36 77 47 43 76 74 50 69 6c 48 65 32 2f 6f
070 71 70 54 38 50 36 53 4d 50 79 42 48 68 47 69 67
080 6b 70 75 45 48 34 50 34 65 35 36 72 74 66 2f 51
090 73 75 5a 70 57 68 79 63 64 49 65 61 0a 6f 69 73
0a0 58 64 63 69 56 33 66 46 6d 4a 56 38 45 6c 33 65
0b0 70 57 75 77 64 4f 41 66 79 70 54 4d 42 69 71 70
0c0 38 6d 32 64 6b 41 51 70 57 63 36 66 5a 55 57 53
0d0 59 54 6c 36 39 5a 6a 48 56 39 39 55 56 0a 35 6d
0e0 4c 4f 55 30 4a 46 50 59 44 71 6c 4c 70 74 55 59
0f0 4c 38 4f 53 33 48 51 6e 4f 4f 56 6d 64 6d 65 4a
100 2b 34 68 50 72 31 39 55 48 6f 39 66 64 33 39 2f
110 76 74 62 6a 7a 4a 33 35 47 61 42 70 39 62 0a 47
120 64 71 6a 49 57 49 57 33 68 4e 72 6e 64 4e 79 61
130 4d 6f 65 72 63 51 57 32 42 32 49 30 34 65 52 73
140 65 79 79 41 75 6b 6c 55 31 35 64 33 37 55 73 36
150 56 71 6f 43 32 6c 70 47 41 67 68 32 4f 47 54 0a
160 70 75 65 70 42 34 5a 5a 47 66 30 4b 6f 4b 57 76
170 59 70 35 38 7a 78 33 4a 49 75 67 43 64 46 54 76
180 4d 5a 55 4a 41 64 52 46 58 37 63 67 44 53 4d 72
190 38 63 78 64 58 45 4b 46 77 73 32 46 6f 58 48 2f
1a0 0a 72 51 49 44 41 51 41 42 0a 2d 2d 2d 2d 2d 45
1b0 4e 44 20 50 55 42 4c 49 43 20 4b 45 59 2d 2d 2d
1c0 2d 2d 0a
Received 256 bytes --> ToBob
00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
000 94 e6 b6 06 e2 18 3f 87 57 32 a4 63 1e 5d 41 13
010 4c c3 b0 95 8a 8d 37 12 bf 15 17 7d d6 d9 0e 16
020 e1 ef 82 d5 b8 e6 67 00 e3 c3 89 94 68 fc 59 53
030 8a 16 80 4f fc a3 dd 81 7a 3c 90 87 d0 5c 88 1f
040 87 52 2d 3b c6 87 3e 50 ed 05 df e6 b4 01 ae 09
050 ab ee e2 a4 db 9a bf be 5c 2c 12 d8 11 43 d8 b7
060 68 5b 2b fd 6b f2 bf df 19 9c 77 6c ac 0e 42 46
070 a1 c6 31 7f ef 4b c2 26 b9 32 10 4c 98 ae af 57
080 db 3a 4b a6 f7 94 9e be 01 8c ab 79 f9 bf b1 11
090 f6 2f 03 d4 5c 5e e9 3a 2f a0 ef f0 47 4f a8 8e
0a0 22 b5 86 4e f8 be 77 2a fc 51 2c f0 6e a1 1e 3e
0b0 7d 69 4a c8 58 68 5b 91 a9 8e 7c 79 10 bf 91 d6
0c0 a4 06 4c 63 02 06 ef 57 30 d5 26 76 12 ef 4e d0
0d0 da ea 3a f4 88 2c 39 ec b1 47 75 b2 2b 04 eb 71
0e0 09 48 a9 5b ec 94 99 99 a1 77 4c 25 da 10 4c d8
0f0 c7 05 4c cd a5 f9 94 b8 1a e2 f8 9a 84 a4 cb 26
Sent by Alice: Hey, Bob!
您可以通过查看 Alice 和 Bob 收到的密钥来意识到公钥已被更改。当 Alice 最终将她的消息发送给 Bob 时，Mallory 现在能够解密它并在屏幕上向您显示其秘密内容。
使用非对称密码和交错协议的密钥交换
如果在通信中引入了额外的安全元素，如身份验证，仍然可以执行非对称密钥交换并意识到攻击。如果您没有这样的工具，您可以做的是尝试减轻攻击，并使 Mallory 越来越难以伪造 Alice 或 Bob 的身份。
交错协议之所以有效，是因为它们只发送消息的一部分，这部分单独无法解密，必须全部放在一起。这里的技巧是 Mallory 需要完美匹配 Alice 和 Bob 的行为（仅仅注入他自己的假密钥是不够的），并且不能只对到达通道的数据进行操作。
协议的行为如下
- Alice 生成一对非对称密钥，一个是私有的，另一个是公共的。
然后她按原样与 Bob 共享密钥。
- Bob 生成一对非对称密钥，一个是私有的，另一个是公共的。
当他收到 Alice 的公钥时，他将用自己的公钥回应。
- Alice 收到了 Bob 的公钥，使用该密钥加密一条消息，但只发送其中的一部分（“n”份中的一份）（示例中是它的一半）。
- Bob 收到消息的一部分并准备一个回复，使用收到的 Alice 公钥对其进行加密。他也只发送消息的一部分（“n”份中的一份）（在提供的示例中同样是消息的一半）。
- Alice 和 Bob 都继续一次发送一块，直到整个消息发送完毕。
- 现在整个消息都在 Alice 和 Bob 手中，他们开始解密并评估内容，看看是否发生了什么不好的事情。
乍一看，协议似乎根本没有提供避免中间人攻击的方法，但您必须考虑到，一次发送的片段是 Mallory 无法解密的。为了成功解密，Mallory 必须存储来自 Alice 的整个消息，解密它并将其发送给 Bob。但 Bob 在收到与 Alice 相同数量的片段之前不会发送任何东西。
Mallory 在这里要做的是向 Bob 承诺一些东西，然后不仅试图伪造密钥，还试图伪造 Alice 的行为。这是一项更困难的任务。发送不同的消息还有一个额外的效果：现在传输的方向与原始 Alice 和 Bob 意图的方向完全不同。
交错式密钥交换示例
将目录更改为匹配 Basic/KeyExchange/Interlocked 目录。与所有其他示例一样，编译它以获得 Mallory 作为中间人攻击者，以及具有交错功能的 Alice 和 Bob 应用程序。
运行 Mallory 将导致与 MITM 版本相同的行为。恶意服务提供商将 passively 监听 Bob 和 Alice 的传入连接，然后它将尝试与他们共享用于消息公钥加密的假密钥。
Creating cryptographic contexts...
1/4 Loading fake Alice private key........DONE
2/4 Loading fake Alice public key.........DONE
3/4 Loading fake Bob private key..........DONE
4/4 Loading fake Bob public key...........DONE
运行 Bob 几乎没有效果，但运行 Alice 现在将在 Mallory 的控制台中显示不同的结果
Received 0 bytes --> Bob
00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
000
Bob on port 53076
Received 0 bytes --> Alice
00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
000
Alice on port 55762
Received 451 bytes --> ToBob
00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
000 2d 2d 2d 2d 2d 42 45 47 49 4e 20 50 55 42 4c 49
010 43 20 4b 45 59 2d 2d 2d 2d 2d 0a 4d 49 49 42 49
020 6a 41 4e 42 67 6b 71 68 6b 69 47 39 77 30 42 41
030 51 45 46 41 41 4f 43 41 51 38 41 4d 49 49 42 43
040 67 4b 43 41 51 45 41 79 34 4b 57 77 62 4d 71 65
050 74 70 68 2f 7a 2f 4d 4c 73 4a 4b 0a 44 4e 4d 58
060 66 48 6c 36 53 65 42 68 65 6e 64 72 55 62 37 4c
070 74 59 2b 73 63 4b 38 43 45 36 59 56 66 49 6c 4b
080 53 70 58 6a 36 48 58 62 45 59 6a 57 2f 51 72 35
090 41 44 47 76 5a 38 34 43 71 39 4d 6a 0a 78 6b 57
0a0 4d 4d 39 50 32 74 53 43 66 75 49 37 47 4a 62 6e
0b0 38 47 47 67 41 38 2f 38 4f 70 4e 57 35 30 6d 51
0c0 6b 6d 41 58 4b 68 73 51 59 4d 34 4d 5a 68 66 38
0d0 4e 46 4f 49 6a 62 32 4c 77 48 4c 64 4f 0a 36 34
0e0 36 6e 70 6a 45 71 4c 6c 57 4a 54 65 6f 4b 70 59
0f0 44 67 6d 31 36 73 59 31 52 4e 62 39 6e 73 37 74
100 51 71 34 6b 2f 55 6e 31 6f 4d 74 74 38 2f 70 6a
110 79 58 53 38 67 4a 79 42 6b 41 51 34 41 79 0a 56
120 75 4f 65 52 70 51 42 78 44 4f 74 73 45 31 72 34
130 35 31 4e 78 62 44 6d 59 34 49 51 56 4d 64 49 6a
140 61 61 51 49 41 35 6f 2f 34 33 6a 6d 62 65 38 63
150 30 54 37 42 45 6d 63 6e 62 4c 48 4e 63 54 72 0a
160 34 4b 35 67 51 73 42 37 6f 6c 44 42 79 44 69 76
170 6a 74 67 79 65 6a 4b 49 42 6e 77 32 4e 4f 4d 4d
180 51 6f 4f 46 51 6d 6a 73 39 39 6a 65 47 79 78 44
190 35 66 36 54 67 4c 46 56 68 57 62 6e 55 43 57 7a
1a0 0a 2f 77 49 44 41 51 41 42 0a 2d 2d 2d 2d 2d 45
1b0 4e 44 20 50 55 42 4c 49 43 20 4b 45 59 2d 2d 2d
1c0 2d 2d 0a
Received 451 bytes --> ToAlice
00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
000 2d 2d 2d 2d 2d 42 45 47 49 4e 20 50 55 42 4c 49
010 43 20 4b 45 59 2d 2d 2d 2d 2d 0a 4d 49 49 42 49
020 6a 41 4e 42 67 6b 71 68 6b 69 47 39 77 30 42 41
030 51 45 46 41 41 4f 43 41 51 38 41 4d 49 49 42 43
040 67 4b 43 41 51 45 41 79 71 53 76 5a 79 62 6f 72
050 30 58 58 72 65 4e 44 51 70 35 69 0a 72 2f 61 6f
060 6c 58 61 33 69 4e 63 36 49 45 72 66 5a 43 6e 61
070 46 38 42 53 50 41 36 75 37 5a 31 71 68 4d 2b 45
080 58 46 52 45 74 63 74 62 70 37 2b 63 2b 73 52 48
090 6e 4c 55 78 6d 6d 5a 58 36 73 49 7a 0a 4d 4a 4f
0a0 6b 38 6a 68 46 61 50 51 6e 38 62 4f 70 46 48 6c
0b0 66 36 42 41 61 69 70 2b 4f 39 7a 5a 51 39 38 4e
0c0 6f 68 43 78 51 45 45 46 57 41 69 51 35 66 32 79
0d0 70 67 6e 44 63 66 37 4f 66 5a 64 58 74 0a 77 2f
0e0 58 42 79 55 6a 55 57 2f 79 39 6f 47 75 33 30 53
0f0 72 63 6f 79 76 30 36 50 2b 62 51 5a 2f 37 75 75
100 34 6c 42 72 70 66 41 61 38 46 45 7a 42 6b 68 61
110 53 6f 44 68 53 55 47 62 34 37 6b 45 33 42 0a 6d
120 79 57 57 51 47 68 61 53 4e 57 2f 69 38 2f 67 55
130 30 43 52 77 4c 55 31 51 58 4e 63 57 64 70 50 30
140 31 45 63 4e 47 63 71 75 5a 77 68 6f 4b 35 66 65
150 50 67 31 39 38 42 2f 75 67 2b 77 74 6e 6a 37 0a
160 4f 32 4c 53 52 33 6a 48 4b 50 48 39 47 34 69 41
170 61 48 6b 62 53 78 46 33 67 7a 75 73 37 42 76 6c
180 6b 4f 67 64 36 4a 73 75 39 35 4c 38 50 77 55 55
190 7a 35 44 72 6f 4f 77 48 78 76 72 71 30 68 7a 6e
1a0 0a 53 51 49 44 41 51 41 42 0a 2d 2d 2d 2d 2d 45
1b0 4e 44 20 50 55 42 4c 49 43 20 4b 45 59 2d 2d 2d
1c0 2d 2d 0a
Received 128 bytes --> ToBob
00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
000 3e f1 34 e8 1a 0c 28 68 f5 1b 2e 12 bc a2 04 61
010 50 4f 7e 3a 50 3e 37 e1 66 0f fd 21 98 3e 77 ee
020 9f e1 bb 40 e9 95 d6 9d c7 6e b7 81 16 55 5d 15
030 10 e9 1a 4a b7 7e 2c be 24 98 a1 e7 8a e9 8a e0
040 87 a5 82 96 c9 b5 04 44 21 98 42 d7 ec 8b 9b 53
050 ee 8b 74 d5 9e a5 f8 f7 ac 91 51 37 68 41 27 5e
060 15 9a fa c7 c8 0b f5 15 71 2f d8 6e 32 4e 7c 57
070 92 4f 0a cc 7c d0 59 d3 33 06 18 d2 3e f0 ed 42
Problem decrypting traffic towards Bob!
Received 128 bytes --> ToAlice
00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
000 01 43 c2 be b0 02 29 83 0a 48 75 74 28 99 0d e0
010 01 73 17 27 1a b4 fd 12 0c f4 1c ea 54 93 66 03
020 f7 a7 d7 be 44 75 d7 41 ba 98 d6 d4 e0 93 4d eb
030 9e 41 5b cb 8f d8 1c fb 6a 54 48 c7 d9 70 66 21
040 cd ed 65 21 21 c4 a2 57 85 a1 bc 17 d0 a7 4a a5
050 7b 74 09 67 4d 98 34 5e 07 f1 9f 6f 0b b0 e4 56
060 0e f5 ef d5 7b f3 bb 84 f5 13 cb ad 85 35 d5 c3
070 09 86 86 17 46 9c 4e 5a 62 d1 2b c4 af cd 0e 43
Problem decrypting traffic towards Alice!
Received 128 bytes --> ToBob
00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
000 86 3c f9 f0 24 23 93 01 9d 44 e1 f6 58 f3 bd 98
010 f7 d7 81 93 33 91 78 01 52 e6 de 90 b6 65 ce fb
020 30 5f 59 1f a5 e8 8c ce 20 a2 54 65 3a b8 54 2e
030 e6 ac 23 20 ad da 2c 90 6a 5a a9 58 2d 14 b3 c9
040 dc 4a 5c b7 ae 3a 4a 05 fb 3b 6f e7 cd 9f 30 08
050 90 54 88 1a 76 2c 68 81 6a 8e fb 76 5a 71 76 9b
060 4f 76 03 34 e1 e8 30 6c 62 58 07 a4 31 8f 9e 7f
070 75 f8 68 1e 40 fe 9e 4e 27 df 0e ac bd b1 04 1b
Problem decrypting traffic towards Bob!
Received 128 bytes --> ToAlice
00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
000 d1 c8 06 3c c0 3d 4d 2c c7 6d b3 a5 3e 4c ac 18
010 b0 a8 a5 f4 1a 40 64 cd a9 ac f8 2f a2 28 25 39
020 5f 89 9c 72 59 ab f5 2d 52 46 88 d0 4a e1 fe 95
030 bd e7 62 e6 d4 a3 50 6a 52 12 dd ef 78 2d 32 c1
040 3f 56 8a ad ea 5d 69 f7 45 bf 2c 46 93 b8 57 45
050 93 d3 71 2d 23 8a 35 fd 03 56 dc 61 e7 10 78 cb
060 d7 b8 bd dd ec 98 a7 6d d8 1b 53 77 d3 18 ed de
070 98 97 ac 2a 9f d6 97 51 18 4e 13 d6 c8 24 81 04
Problem decrypting traffic towards Alice!
在这种情况下，Mallory 不知道 Alice 和 Bob 之间会交换什么样的消息，但他向他们承诺了一个假的公钥，所以他必须处理经过的消息。如您所见，密钥交换阶段的执行没有太大差异，但现在 Alice 和 Bob 只发送部分消息，而不是整个消息。
此信息在没有另一部分的情况下无法解密，但必须向 Bob 发送一些东西以触发响应。作为一个错误的行为（对此示例有用），如果 Mallory 无法解密消息，他会将其未经修改地发送到目的地。Alice 和 Bob 之间交换的两条消息的所有四个部分都发生了这种情况。
此操作的结果是，由于这些消息是使用假公钥加密的，因此会得到一条不可读的消息，这也会触发一个通知，表明网络层面正在发生一些不好的事情。实际上，在 Alice 的控制台上我们可以看到以下报告
Basic Cryptography: Interlocked protocol
Setting up cryptographic contexts...
1/2 Loading private key...................DONE
2/2 Loading public key....................DONE
Initializing network..........................DONE
Presenting to network provider................DONE
Preparing Bob context...
1/3 Requesting Bob public key.............DONE
2/3 Receiving the key.....................DONE
3/3 Preparing Bob context.................DONE
Key received from Bob:
00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
000 2d 2d 2d 2d 2d 42 45 47 49 4e 20 50 55 42 4c 49
010 43 20 4b 45 59 2d 2d 2d 2d 2d 0a 4d 49 49 42 49
020 6a 41 4e 42 67 6b 71 68 6b 69 47 39 77 30 42 41
030 51 45 46 41 41 4f 43 41 51 38 41 4d 49 49 42 43
040 67 4b 43 41 51 45 41 71 58 64 71 65 51 67 37 48
050 2b 37 51 4d 31 30 6f 37 58 6a 37 0a 65 2f 34 44
060 66 69 56 6a 6e 58 43 65 54 65 44 56 46 31 2b 55
070 66 32 39 6d 68 6c 46 70 46 34 38 36 50 4c 63 38
080 4d 6d 56 6a 33 76 63 6e 72 75 64 76 57 55 45 6f
090 55 52 67 71 56 4e 30 74 64 71 37 46 0a 45 7a 61
0a0 72 71 31 54 76 6d 75 50 33 2f 6f 71 5a 43 66 77
0b0 36 7a 45 45 78 45 53 30 2b 50 39 43 71 58 58 35
0c0 77 73 52 79 54 62 36 6a 79 6f 50 59 47 54 31 64
0d0 71 6c 57 4d 72 37 34 79 50 5a 4c 43 44 0a 6f 72
0e0 44 36 4a 31 78 62 6b 42 56 6c 6d 6a 4a 37 4f 46
0f0 2f 50 4d 62 37 38 51 63 49 52 37 66 68 53 2f 53
100 75 59 4c 35 59 4c 34 30 4c 48 50 34 5a 52 71 31
110 52 6c 70 34 39 64 72 74 47 53 67 44 58 62 0a 45
120 51 4b 2b 72 45 43 66 39 58 4d 35 59 35 33 67 66
130 6a 73 51 65 76 41 76 6f 58 41 68 45 49 39 65 53
140 4a 34 37 55 59 69 78 58 53 39 44 38 51 59 2f 78
150 51 43 65 74 4f 37 36 52 64 6b 62 69 65 37 68 0a
160 79 71 63 45 38 76 6a 4f 34 2b 71 4f 47 4a 45 4d
170 6a 2b 32 78 72 6c 4c 43 33 2f 58 57 72 37 66 54
180 33 42 45 57 51 5a 6f 6a 4b 6d 4c 43 78 58 58 36
190 50 58 4f 58 37 35 68 2b 64 6a 46 4f 35 59 67 33
1a0 0a 31 51 49 44 41 51 41 42 0a 2d 2d 2d 2d 2d 45
1b0 4e 44 20 50 55 42 4c 49 43 20 4b 45 59 2d 2d 2d
1c0 2d 2d 0a
Sending private message to Bob: "Hey Bob!"
Processing Bob answer.........................FAILED; error while processing
这意味着我们无法用我们的私钥（它从未离开过我们的计算机）解密 Bob 应该用我们的公钥加密的消息；这显然是通信被篡改的痕迹。
使用对称和非对称密码的密钥交换
由于每种加密密码都有其优缺点，在现实世界中，它们通常被组合在一起以从两种方法中获得最佳效果。非对称密码通常很慢，但独立于一个作为单点故障的中央权威机构。另一方面，对称密码是轻量级的，在时间和空间方面提供了最佳性能（更快且密钥更小）。
同时使用两种密码会导致以下协议
- Alice 生成一对非对称密钥，一个是私有的，另一个是公共的。
然后她按原样与 Bob 共享密钥。
- Bob 生成一对非对称密钥，一个是私有的，另一个是公共的。
当他收到 Alice 的公钥时，他将用自己的公钥回应。
- Alice 现在创建一个新的对称会话密钥，然后用 Bob 的公钥加密它，最后发送给 Bob。
- Bob 收到密钥并解密消息。然后他获得了可以用于支持他与 Alice 之间进一步通信的对称会话密钥。
- 现在通信使用对称密钥密码进行。
现在，昂贵的非对称密码操作用于通信的初始设置，前提是额外的机制（如身份验证或使用 PKI（公钥基础设施））确保消息的身份是可信的。一旦这一步完成，所有后续通信都使用对称密码进行，这保证了更好的性能。为安全起见，可以定期更新会话密钥，以破坏窃听者拦截和猜测/计算所用密钥的能力。
非对称和对称密码示例
将目录更改为项目源代码下的 Basic/KeyExchange/KeyAndMessage 目录。与任何其他文件夹一样，您可以直接 make 该单个原型，或通过在根目录中调用 make 将其与其他所有原型一起构建。
在此实验中，您将有一个被动的 Eve 为 Alice 和 Bob 提供服务。她将静默监控数据流向所需目的地。这里假定 Alice 已经以某种方式获得了 Bob 的公钥，无论是通过与 Bob 的直接通信（见前几章）还是通过使用 PKI。
首先运行 eve，然后是 Bob，最后是 Alice。Bob 会坐下来监听来自 Alice 的传入会话密钥，该密钥在第一条使用非对称密码技术加密的消息中交换。Eve 会通过考虑交换的消息大小并猜测使用了这种密码来注意到这一点。
Received 256 bytes --> ToBob
00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
000 4d 6c 7b a1 b5 46 a8 26 51 7c 11 cc 29 ec 76 0b
010 90 e1 a3 0a 84 7b 21 eb 54 96 ee 57 4d 1e ab 42
020 a7 9f d6 6f 41 5d f6 2b 4d 3d 4f c7 53 ec aa bf
030 f2 41 4f d1 fb 12 f9 ef 94 c1 fe b4 45 aa dd fa
040 32 1c 04 eb 80 7b 75 a3 61 50 cc b5 74 2a 48 79
050 48 7d c1 eb c4 15 b6 d0 9a 4f 3e a4 9b 4d d9 c7
060 99 aa ab 7b 6a 6b a7 cd 25 16 36 e3 dd 4c 1d 85
070 b2 de 23 d0 f9 b5 3d d0 8c d0 79 ec 49 ec 95 a1
080 c6 ea 8e e7 e1 c2 57 e1 05 f5 7d d1 e3 f8 6d 10
090 c9 28 8a e4 ab 15 d4 54 07 e9 63 74 53 a7 0c 93
0a0 45 3a 4f dd 9f e9 0b 11 4f de 14 14 06 b1 24 a3
0b0 27 ec ad db 8e e6 ad f1 1e 87 c6 1a 76 21 86 52
0c0 0e 81 0e 72 81 dd 66 8b 89 5f f9 5d 0c 02 18 33
0d0 4b 80 b1 05 5c 73 e5 76 bd 3a 28 98 ce f6 9d e9
0e0 bb 31 d1 bb 49 fc 75 f1 f0 0f d0 c5 4f 5d 32 5b
0f0 d9 94 e0 2d 55 a2 e0 48 15 e4 d4 a3 a3 46 91 c5
在这次初始传输之后，其中将包含后续消息的对称密钥，Alice 切换技术并开始使用 AES-256 进行通信。Eve 拦截并转发的下一条消息是
Received 32 bytes --> ToBob
00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
000 2f 73 cf b0 fc 46 93 bd 65 d9 92 b0 7c d4 8c cc
010 ca e9 b7 03 90 93 2d af 6d 3d 90 50 69 6b 25 f4
在 Bob 方面，他将使用自己的私钥解密初始消息。因为我们假设公钥已正确安全地交换，如果他无法解密此消息，他会假定发生了篡改。收到会话信息后，他设置一个对称密码描述符并开始使用它来处理来自 Alice 的后续传入消息。
BasicCryptography: Key and Message exchange
Setting up cryptographic contexts...
1/2 Loading Bob private key...............DONE
2/2 Loading Bob public key................DONE
3/3 Loading Alice public key..............DONE
Initializing network..........................DONE
Presenting to network provider................DONE
Waiting for Alice session.....................DONE
Alice-Bob Key: 30 31 32 33 34 35 36 37 38 39 30 31 32 33 34 35 36 37 38 39 30 31 32 33 34 35 36 37 38 39 30 31
Input vector: 30 31 32 33 34 35 36 37 38 39 30 31 32 33 34 35
Getting Alice message.........................DONE
Message is: Hey Bob!
Terminating...