Skip to content

Latest commit

 

History

History
467 lines (264 loc) · 28.5 KB

3.md

File metadata and controls

467 lines (264 loc) · 28.5 KB

三、强加密

如果操作正确，强加密甚至可以对敌方（如敌方军事机构）隐藏数据。强加密的两种主要方法是 AES 和 RSA，这两种方法都得到了美国政府的批准。你不需要有编程经验来学习这一点，你也不需要任何特殊的计算机；任何可以运行 Python 的计算机都可以执行这些项目。此外，你不需要太多的数学知识，因为我们不会发明新的加密技术，只是为了学习如何使用标准的预先存在的加密技术，这些加密技术只需要非常基本的代数。

在本章中，我们将介绍现有的：

  • AES 强加密
  • ECB 和 CBC 模式
  • 甲骨文攻击
  • RSA 强加密
  • 下一步是什么？

AES 强加密

在本节中，我们将了解高级加密标准（AES），私钥加密，密钥和块大小，如何影响 AES，以及 Python 和混淆与扩散。

AES 是美国国家标准协会批准的加密标准，被认为是非常安全的。它甚至被批准用于储存秘密军事信息。这是私钥密码术，这种密码术已经使用了数千年，发送方和接收方都使用相同的密钥。这是一种分组密码，因此输入数据必须放在 128 位长的块中，一块明文用密钥加密，产生一块密文：

有三种密钥大小：128、192 和 256 位。最常见的 AES 类型是 128 位密钥大小，这就是我们在本例中使用的。在 Python 中，它非常容易使用。

首先，您需要从crypto cipher导入AES模块，然后您需要一个 16 字节的密钥和明文，这是 16 字节的整数倍。然后，您将使用密钥创建一个新的 AES 对象，然后使用 cipher encrypt 进行计算。这将为您提供一个 16 字节的字符串，它可能无法打印，因此最好将其编码为十六进制以将其打印出来；当然，如果你解密它，你会回到原始的明文。这有许多理想的加密特性，其中之一就是混淆。如果你改变一点密钥，它就会改变整个密文。

因此，如果我们将密钥更改为kex，您将看到所有密文都会更改。这就是你想要的。两个非常相似的键产生完全不同的结果，因此在结果中找不到任何可以用来推断键信息的模式。

类似地，扩散也是一种可取的特性，如果使用同一密钥对某个内容加密两次，但即使更改了一位明文，整个密文也会更改。请参见以下示例：

这里我们有字节，我们得到相同的433以6a8结尾。如果我们将最后一个字母改为t，您可以看到它以90c开头，以5d2结尾；就是完全变了。

让我们看看 Python 中的：

  1. 打开终端窗口，启动python。我们将输入以下命令，如 sceenshot 中所示：

  1. 我们导入AES模块，其中有一个 16 字节的密钥和一个 16 字节的明文。我们已经创建了一个 AES 对象，对其进行了加密，然后在这里打印出十六进制值：

  1. 现在，我们更改密钥：

在这里，我们转到键行并将其更改为z，然后再次执行，使用该键创建一个新的 AES 对象。执行加密并再次打印结果，您会发现一切都不同了。

现在以b开头，以4结尾，完全变了。

  1. 现在，我们将密钥保留在原处，并更改明文。让我们把t改为F。现在，如果我们对其进行加密并以十六进制打印结果，那么一切都再次发生了变化；即使这是与上面的键相同的键：

因此，这显示了混淆和扩散，这是理想的特性。在下一节中，我们将讨论 ECB 和 CBC 模式。

ECB 和 CBC 模式

我们将比较E****电子码本（ECB）和密码块链接（CBC）并向您展示如何在 Python 中实现 AES CBC。

欧洲央行

在 ECB 方法中，每个明文块都分别使用密钥加密，因此如果有两个相同的明文块，它们将产生相同的密文：

如果您在这里有一个像图像这样的大面积纯色区域，如灰色和黑色，然后对其进行加密，您只会得到不同的颜色，但图案不会改变：

那不好。你仍然可以看到这是一张企鹅的照片，这不是大多数人对加密的期望。您希望加密会隐藏数据，因此查看加密数据的攻击者无法辨别消息是什么，而此处该属性不存在。

因此，CBC 被认为是解决这一问题的最佳方案。

CBC

除了密钥之外，您还添加了一个初始化向量，在加密之前它与明文异或。然后对于下一个块，使用加密产生的密文，并将其用作第二个块的初始化向量。其输出用作第三个块的初始化向量。因此，即使每个块中输入的明文相同，每个块中的密文也会不同：

这会导致更多的混淆：

你可以看到企鹅现在是完全不可见的，所有的字节都是随机的，所以这几乎是所有用途的首选。

为了在 Python 中实现这一点，下面是我们如何实现之前的 AES，即 EBC 模式。默认情况下，您不指定模式。

如果要使用 CBC 模式，请输入以下命令：

创建密码对象时的 AES 模式 CBC。您还必须提供一个初始化向量，它可以是 16 字节，就像密钥一样。如果加密一个 16 字节的文本块，由于初始化向量的原因，结果没有明显差异，但它只是一个十六进制的块。要查看其效果，需要将明文变长。当你加密它时，你会得到一个十六进制的 blob。这是 ECB 模式，它不会删除数据中的所有模式。这是具有相同重复输入的 CBC 模式。如您所见，输出没有模式，无论走多远都不会重复。因此，它可以更有效地隐藏数据。

让我们来看一看。我们在终端中启动 Python，然后添加以下代码：

因此，您可以在 ECB 模式下看到 16 字节密钥和 16 字节明文 AES。我们将其加密并打印答案。

如果我们想让它更长，我们添加以下内容：

在 Python 中，您可以将字符串对象相乘，如果您只是将其打印出来，您将看到三次相同的结果。

现在我们可以加密该plain3：

当我们把它打印出来的时候，它会有 33 年的重复模式。现在，如果我们改变模式，我们需要一个iv：

我们只需要 16 个字节，所以我们只需要 16 个字节到iv。接下来，我们创建一个新的AES对象。在iv中，我们再次加密plain3，并再次打印结果。

你看它有61f，你可以看到不再有任何重复。因此，如果您真的想隐藏输入，这是一种更有效的加密方法。

甲骨文攻击

在本节中，我们将了解填充在 PKCS#7 系统中的工作原理，然后向您展示一个带有PADDING ERROR消息的系统。另外，我们还将处理填充甲骨文攻击，这使我们能够制作密码，解码我们想要的 20 条明文。

以下是加密例程：

我们将有三个数据块，每个 16 字节长。我们将在 CBC 模式下使用 AES 对数据进行加密，因此会出现初始化向量和密钥。生成三个密文块，第一个块之后的每个块都使用前一个加密例程的输出作为初始化向量，与明文进行异或。

以下是 PKCS#7 填充的工作原理：

  • 如果需要一个字节的填充，请使用01
  • 如果需要两个字节的填充，请使用0202
  • 如果需要三个字节的填充，请使用030303
  • 等等

如果我们这里有一个只有 47 字节长的消息，那么我们不能填充最后一个块，所以我们必须添加一个字节的填充。可以使用多种数字作为填充，但在这个系统中，我们使用一个二进制值 1，如果需要一个字节的填充，如果需要两个字节，那么两个字节都使用两个，三个字节都使用三个，以此类推。这意味着，如果我们解密它，我们将有三个密文块。我们解密后会得到 47 字节的信息：

这里的最后一个字节将始终是填充字节，这将是0-1，一个二进制值1。

下面是一个可以攻击的易受攻击系统的示例。这与我们之前使用的技术相同，我们只是使用 AES 和 CBC 模式加密，您可以将其保存在pador.py中，然后您可以导入它以使其易于使用和更真实。已经有真正的系统使用这个。因此，我们导入、加密和解密方法，这样我们就可以放入 47 管道消息并对其进行加密。我们将得到一长串十六进制输出。

如果我们解密，我们将得到原始输入加上最后一个字节的01。x01 是二进制值为1的单字节的 Python 表示法。如果修改输入时仅保留前 47 个字节，将最后一个字节更改为A或65并解密，则会出现填充错误。此错误消息看似无害，但实际上它使完全破坏加密成为可能。

让我们来看一看：

  1. 打开终端，启动python。
  2. 我们将输入以下命令：

  1. 我们将加密和解密例程。你可以看到我们有明文。当我们加密 47 字节的明文时，会得到一个长的二进制 blob：
941dc2865db9204c40dd6f0898cbe0086fc6d915e288ed4ef223766a02967b81c6c431778a40f517e9e4aa86856e0a3b68297e102b1ec93713bf89750cdfa80e
  1. 当我们解密它时，我们得到以下结果：

我们可以看到，它实际上在它的末尾添加了一个字节的填充。

现在，我们应该做一个变形的。如果我们将修改后的文本设置为与原始明文相同的字符47，然后在末尾添加"A"，当我们解密它时，我们得到'PADDING ERROR'：

这就是我们可以用来破坏系统的错误消息。下面是 oracle 攻击的填充工作方式的变化：

  1. 将密文[16:31]更改为任意字节
  2. 更改密文[31]直到填充有效
  3. 中间[47]必须是1

以下是 CBC 的示意图：

保留密文的前 16 个字节。将此更改为您喜欢的任何内容，例如“全部为”，然后对其进行解密。将会发生的是，因为您更改了第二个块中的字节，第二个块将变成随机字符，第三个块也会变成随机字符。但它会给你一个填充错误，除非最后一个块的最后一个字节是 1。所以，你是蛮力。您将一个字节更改为所有 256 个可能的值，直到该字节变为1，当这种情况发生时，您知道该值为1。您知道这个值，因为它没有给您一个填充错误消息，您可以在这里对它们进行异或以确定这个中间值。因此，从左开始逐字节处理，可以确定这些中间值。如果你知道它们，你可以输入密文，让你喜欢的任何东西出现在第三个区块。因此，即使您不知道密钥或初始化向量，也可以破坏加密。

下面是执行此操作的代码：

并将获得以下输出：

我们将密文设置为第一个原始 16 字节的密文，然后是 15 字节的A。然后我们通过所有可能的256值改变下一个字节，并添加第三个数据块，保持不变。在那之后，我们看看什么时候我们不再得到填充错误，那将是234，所以中间值是234异或一：

  1. 现在，如果我们想取回下一个字节，我们必须安排两个字节的填充，这两个字节都是2，如图所示：

所以，密文46和47的最后两个字节都是两个。因此，我们将 ciphertext31设置为创建两个所需的值。既然我们知道了中间值，我们就可以计算它了。

  1. 我们改变密文30，直到填充有效，这将确定中间文本的下一个字节：

  1. 保持第一个块不变，并在下一个字节中添加 14 个字节。将字节保留在所选的值233，这样您就知道解密输出的最后一个字节将是2，当填充错误消息消失时，您可以获取该数字，将其与2异或，然后获得中间值的下一个值。所以，现在我们可以制作消息了。为了得到更多的字节，我们需要重复更多次，但是对于这个演示，我们只需要一个字母长的消息。我们将生成一个A，后跟一个二进制值1，用于有效填充。这是我们的目标，为了做到这一点，我们所要做的就是将密文30和31设置为这些选定的值：

    • ciphertext[30] = ord("A") ^ 113
    • ciphertext[31] = 16 235

  2. 因为我们知道中间值是113和235，所以我们只需要将这些中间值与我们想要的值进行异或运算。

  3. 我们将创建密文，该密文将解密为以A结尾的消息和以1结尾的二进制消息，让我们来看看。现在，这个有点复杂，所以我们选择将一些文本保存在文本编辑器中，以便我们可以分阶段进行操作：

  1. 下面是我们的 Python：
>>> from pador import encr, decr 

>>> prefix = c[0:16] + "A"*14
>>> for i in range(256):
...   mod = prefix + chr(i) + chr(233) + c[32:]
...   if decr(mod) != "PADDING ERROR":
...     print i, "is correctly padded"
  1. 好的，我们导入了这个库，反正我们已经有了。在这里，我们保持前 16 个字节不变，并用A填充 15 个字节。然后，我们有一个循环，它改变下一个字节的所有可能值，并保持第三个数据块不变。我们运行循环，直到不再出现填充错误。这告诉我们，234是给我们正确填充的值：
234 is correctly padded
  1. 因此，我们将234带到1，它告诉我们中间值，全部切向压痕右侧，因此它是234XOR1。这告诉我们该值为235。这是中间值。对于下一位，使用非常类似的过程，因此现在我们有 14 个字节的填充。我们将改变下一个字节，之后的字节是233，选择它总是在末尾给我们一个2。所以，当我们运行这个循环时，它被正确地填充在115：
...
115 is correctly padded
  1. 所以，115XOR2是113：
>>> 115 ^ 2
113

因此，113是中间值的下一个字节。

  1. 现在我们知道了这两个数字，235和113，我们可以控制明文的最后两个字节。现在，我们将保持第一块输入数据不变。我们有 14 个字节的填充：
>>> prefix = c[0:16] + "A"*14 
>>> c30 = ord("A") ^ 113 
>>> c31 = 1 ^ 235 mod = prefix + chr(c30) + chr(c31) + c[32:] 
>>> decr(mod)
  1. 我们选择制作A和一个包含两个字节235和113的二进制文件。当我们创建修改后的密文并对其解密时，我们得到以下消息：
"This simple sent\xc6\x8d\x12;y.\xdc\xa2\xb4\xa9)7c\x95b\xd1I\xd0(\xbb\x1f\x8d\xebRlY'\x17\xf6wA\x01"

第一个数据块未被修改。第二个块和第三个块的大部分都变成了随机字符，但是我们控制了最后两个字节，我们可以让它们说出我们想要的任何内容。因此，我们能够创建密文，该密文将至少部分解密我们选择的两个值，即使我们不知道密钥或初始化向量。

RSA 强加密

在本节中，我们将介绍公钥加密、RSA 算法和 Python 实现。

公钥加密

在公钥加密中，我们解决了这个问题：例如，谷歌希望从用户那里接收机密数据，如密码和信用卡号码，但他们没有安全的通信渠道；他们拥有的是公共互联网，任何发送的数据都可能被任何数量的攻击者窃听。因此，无法提供共享密钥，而 AES 等对称加密算法无法解决此问题。这就是公钥加密的用武之地。

谷歌创建了一个密钥对。他们对私钥保密，不告诉任何人，并且公开密钥，以便任何人都能知道。每个想把秘密发送给谷歌的人都可以用公钥加密，然后通过不安全的渠道发送，因为唯一能解密的人是谷歌，他拥有私钥。邮箱是这样工作的。任何人都可以去邮箱，把邮件放在最上面的插槽里，但最下面的门是锁着的，只有持有私钥的邮政工作人员才能把邮件拿出来。私钥和公钥必须是相关的，但它们必须通过一个单向函数来关联，这样就可以很容易地从私钥中计算出公钥，这也是谷歌首次设置密钥对时必须做的。但是从公钥计算私钥是非常困难的，所以公开公钥是安全的，没有人会找到私钥。

RSA 算法

有多种单向函数可用于此目的，但在 RSA 中，该函数分解了大量：

  • 私钥d由两个大素数组成：p和q
  • 公钥是n = p * q与任意值e的乘积
    • 如果p和q较大，则将n分解为p和q非常困难

如果你将两个素数p和q相乘以生成它们的乘积n，那么将n分解为p和q是一个众所周知的难题。如果p和q足够大，它就基本上不可能实现。这是单向函数。您可以轻松地将p和q相乘来创建公钥n，但公钥的知识实际上无法用于确定p和q：

  • 公钥：这是两个数字，(n,e)
    • e可以是任何素数，通常为65537
  • 加密：y = x<sup class="calibre64">e </sup>mod n
  • 解密：x = y<sup class="calibre64">d</sup> mod n 
    • x为明文，y为密文

因此，公钥是n，它是两个素数和另一个任意数e的乘积，通常就是这个值65,537。任何想要秘密发送明文的人，x，将其提升为e、模数n的幂，并通过不安全的渠道（如互联网）将这些乱码发送给接收者。收件人拥有私钥，因此他们可以找到解密密钥d，并将密文带到d模n，这将转换为解密消息。解密密钥的计算方法如下：

  • phin = (p-1) * (q-1)
  • d*e  = 1 mod phin

由于谷歌知道p和q的秘密，他们可以计算这个数字phin，也就是p - 1，乘以q - 1，然后选择一个解密密钥，这样d乘以e就是n的1模Phi。其他人无法进行此计算，因为他们不知道p和q的值。因此，在 Python 中，您可以导入RSA模块，然后生成任意长度的密钥。在本例中，我们使用了2048位，这是当前国家标准协会的建议。然后，它们有一个公钥。有一条消息需要加密，你对它进行加密，结果是这个很长的密文，它有2048位那么长。密文很长，而且计算速度很慢，因此通常不使用此方法发送长消息。您在 RSA 中所做的只是发送一个密钥，然后使用 AES 对该点之后的所有内容进行加密，以加快计算速度。本章介绍了一种称为教科书 RSA 的东西，它包含许多基本成分，但对于实际使用来说还不够安全，因为您必须添加 RFC 8017 中指定的填充物。这会在消息中添加哈希值、掩码和填充，并保护密钥免受某些攻击。让我们用 Python 来看看这个。

Python 实现

下面是我们如何在 Python 中实现我们所讨论的内容：

  1. 我们启动python，然后添加以下代码：

  1. 显示的最后一步仅需 2 到 4 秒即可生成密钥；这是因为它必须找到两个大素数，这是非常困难的计算：

  1. 它必须猜测一个数字并进行测试，通常，它必须对每个大素数进行 100 多次猜测，所以这个过程非常耗时。但是，它是自动发生的，现在我们可以用密钥加密消息，生成这样一个很长的密文：

  1. 现在，我们可以对此进行测试，看看我们是更改消息的一位，还是使用纯文本并将最后一个字母更改为f。如果我们对其进行加密，结果将类似于以下内容：
>>> plain = 'encrypt this messagf'
>>> ciphertext = publicKey.encrypt(plain, 0) [0
... ciphertext = publicKey.encrypt(plain, 0) [0
keyboardInterrupt
>>> ciphertext = publicKey.encrypt(plain, 0) [0]
>>> print ciphertext.encode ("hex")
  1. 现在，我们打印结果：

如您所见，所有4ac都转到1dc，然后在578到633结束。这是强加密的理想特性。输入中的任何更改都会更改所有输出剪辑，约占位的一半。

挑战–使用类似因素破解 RSA

在本节中，我们将介绍一些主题，如 Python 中的大整数和decimal库。我们还将看一个分解大量因子的示例，然后是两个需要您解决的挑战。

Python 中的大整数

Python 可以进行乘法和除法运算——以及任意大整数的完全精确乘法和除法运算：

如果我们有1001，然后我们计算1001的平方，我们当然会得到正确的答案；即使我们取一个像10**100 + 1这样的数字，它也能正确地得到 100 个位置的数字，每端都有一个1。现在，如果我们把这个数字平方，它会再次得到正确的结果，一直到两端的一。

因此，对于简单的整数运算，Python 的精度是无限的。但是，如果我们想要平方根，我们需要导入一个math库：

正如您在前面的代码中所看到的，math库不保留任意数量的位置。如果我们取10 **100 + 1并求平方，然后取平方根，我们就得不到10 **100 + 1。我们得到了10 ** 100，这意味着它四舍五入到一些小于100的地方，这在很多方面都是可以的。然而，这对于我们想要在这里做的事情来说是不好的，这就是因子大整数。

为此，您使用decimal库，我们将导入它，如图所示：

如您所见，我们已经导入了decimal库，并将值设置为a作为10 **100+ 1。这里b等于一个平方，然后不用math库计算b的平方根，而是用decimal库计算b的十进制值。使用平方根法，这会再次给出错误的答案，因为默认情况下，decimal库会舍入这些内容。但是如果你把精度设置得更高，你会得到正确的答案，这就是为什么decimal库更适合我们的目的。这个getcontext().prec命令允许我们设置它以保持足够的位置，使其尽可能精确。

好吧，所以，在一般情况下，你不能考虑大量的数据，这就是 RSA 安全的原因。但是，如果使用数字犯了错误，并且在某种程度上可以预测，则可以破解 RSA：

这里的错误是使用两个接近的素数因子，而不是为这两个素数因子选择独立的随机数。这个大数是两个素数因子的乘积，所以你可以把它因子化。因此，如果我们将该数字放入一个名为n的值中，我们将精度设置为50位，并计算平方根。我们发现平方根是1后跟许多零，并且结束于83+一个分数。

现在，如果这个数是两个素数的乘积，两个素数靠得很近，那么一个数必须小于平方根，另一个数必须大于平方根。

因此，如果我们简单地从平方根开始，通过每次向后跳 2 来尝试接近平方根的数字，我们最终会找到素数因子，我们做到了：

当然，我们可以向后跳 2，因为偶数肯定不是素数，所以我们不需要测试偶数。

我们可以看到，现在我们已经找到一个数，n模的模，这个数是零，所以这是一个素因子。

我们可以通过将n除以第一个素因子得到另一个素因子：

这是原始数字，n，它是两个素数的乘积，我们有一个素数；q在p的上方n可以看到。为了测试它，如果我们计算p*q，我们会再次得到原始数字。因此，我们在p和q中考虑了大量信息，这些信息足以破解 RSA。

那么，让我们在 Python 中尝试一下。到终端运行python：

所以，我们有n等于所示的大数字。我们将此编号导入decimal库，并将位置设置为50位置。现在，如果我们取平方根，我们得到1后面跟许多零，然后是83，然后是一个分数。然后，我们复制平方根的整数部分：

现在我们将p设置在该数字后面的数字范围内，如下所示：

>>> for p in range(100000000000000000083, 100000000000000000030, -2):

这就开始了一个循环，我们所要做的就是打印：

...  print p, n%p
...

它将计算n模量p，该模量为零。如果是整数倍，按两次回车运行循环：

所以我们可以看到这个数字是p：

100000000000000000039 0

如果我们复制该数字，我们可以将p设置为等于该数字，并且可以将q设置为n大于p：

>>> p = 100000000000000000039
>>> q = n/p

如果我们打印，我们将获得以下内容：

您可以看到n与p*q匹配。所以，我们现在把这个长的数分解成它的补码素数。

这是第一个挑战：

这是第二个挑战：

在这两种情况下，您都可以考虑它们。

下一步是什么？

物联网（物联网）前景广阔，很快将连接数十亿台设备。对于物联网而言，安全一直是一个主要问题。但好消息是，加密技术提供了各种选项来保护物联网免受黑客攻击；因此，它是即将到来的物联网时代的关键。

物联网中的密码学

当我们谈论在物联网中使用密码时，我们谈论的是跨通信堆栈的许多层使用密码。如果我们查看 OSI 模型，我们可以看到加密在第 2 层和第 2 层使用，链接在第 2 层运行，网络在第 3 层运行，传输在第 4 层运行：

在应用层，加密技术还通过身份验证和加密来保护通信。在我们开始描述物联网协议的特定加密方法之前，让我们先谈谈现有无线协议的利用工具的可用性。随着物联网的成熟，请记住，有许多工具可用于利用物联网无线通信协议，这些工具将继续快速跟上为支持物联网而引入的新技术。

例如，以 1989 年推出的 Wi-Fi 802.11 为例，AirCrack 工具于 2004 年推出，至今仍是一种受欢迎且支持良好的工具。还有许多工具可用于利用蓝牙通信和蜂窝通信。

除此之外，驱动加密的密钥必须在设备（模块）级别以及整个企业中进行安全管理。让我们来探索其中的一些。

ZigBee 加密密钥

ZigBee 使用许多密钥进行加密操作：

  • 链路密钥：基于使用厂商预配置的主密钥建立。链路密钥在两个 ZigBee 节点之间提供点对点安全连接。链接密钥还用于建立派生密钥，包括数据密钥、密钥传输密钥和密钥加载密钥
  • 密钥传输密钥：该密钥是以 1-octet 字符串 0x00 作为输入字符串，在链路密钥下执行专用密钥哈希函数的结果

ZigBee 密钥管理的复杂性

如前所述，密钥管理具有挑战性。让我们看看密钥管理的挑战性。以 ZigBee 协议为例。ZigBee 网络中可以使用三种主要类型的密钥。主密钥通常由供应商预先安装，并在两个 ZigBee 节点生成链接密钥时保护它们之间的交换。链路密钥支持节点间通信，网络密钥支持广播通信。

例如，密钥管理功能可以内置在实用工具的媒体管理软件中，并且可以作为独立软件提供。但是，所有这些密钥都需要在其整个生命周期中得到充分的保护。

蓝牙–蓝牙

蓝牙低能协议采用加密技术来配对设备，以实现未来的关系。蓝牙 LE 在这些加密过程中使用各种密钥，包括长期密钥（LTK），用于生成链路层加密的 128 位密钥和连接签名解析密钥（CSRK），用于在 ATT 层对数据进行数字签名。

有了这些，我们就到了这本书的结尾。加密应用程序应专门针对威胁环境进行定制。密码学基于强大、设计良好的算法，并与通信堆栈的所有层相关联。它无处不在，对物联网系统的安全至关重要。

总结

在本章中，我们介绍了 AES，当今最常用的私钥系统，以及它的两种模式，ECB 和 CBC。我们介绍了 oracle 对 CBC 的填充攻击，当错误消息向攻击者提供的有关加密过程的信息超过其应有的数量时，这种攻击就成为可能。

最后，我们介绍了 RSA，这是目前用于通过互联网发送秘密的主要公钥算法，我们还研究了在两个素数相似而不是独立随机选择的情况下破解 RSA 的挑战。我们还展望了加密技术的未来，以及它将如何帮助物联网设备的安全。