信息安全 on 蛋蛋忧桑

访问控制策略

Thu, 08 May 2025 14:32:12 +0800

1. DAC（Discretionary Access Control）

自主访问控制

核心特点：

资源拥有者决定权限：用户对其拥有的资源（如文件）有控制权，可以授予或撤销他人的访问权限。
权限可继承/传播：被授权的用户可以继续把权限授予其他用户（这可能导致“权限扩散”）。

举例：

用户 A 拥有一个文件 file.txt，他设置权限让用户 B 也能读取它。
用户 B 如果有权，也可以把这个文件分享给用户 C。

类似系统：

类 Unix 的系统默认使用 DAC，通过 chmod、chown 控制文件权限。

2. MAC（Mandatory Access Control）

强制访问控制

核心特点：

系统控制访问权限：用户无权修改自己的资源权限，所有访问规则由系统策略统一定义。
基于安全标签（level）：对象（资源）和主体（用户）都有安全级别，比如“机密”、“受限”、“公开”，系统强制根据这些级别控制访问。

举例：

一个“秘密”级别的文件只有“秘密”级别或更高级别的用户才能访问，不能随意共享。
用户即使拥有文件，也无法更改其访问权限。

类似系统：

SELinux（Security-Enhanced Linux）
AppArmor（Ubuntu 上使用）这些系统就使用了 MAC 模型。

3. RBAC（Role-Based Access Control）

基于角色的访问控制

核心特点：

以“角色”为中心：权限分配给“角色”，用户根据其角色获得权限。
灵活、集中管理：适合组织结构复杂、职责分明的环境。

举例：

角色“管理员”拥有系统配置权限；角色“用户”只能读写自己的数据。
用户 A 被分配为“管理员”，系统自动赋予所有“管理员”权限。

类似系统：

多数企业应用和身份管理系统（如 Active Directory、Kubernetes、数据库权限管理）使用 RBAC。

4. TBAC（Task-Based Access Control）

基于任务的访问控制

核心特点：

权限与具体任务绑定，而不是与用户或角色绑定。
用户只有在执行某个“已授权任务”时，才能获得所需权限。
强调“动态激活权限”，避免静态分配带来的过度权限问题。

举例：

某人是“医生”角色，但只有在处理某个病人的病历任务时，才能访问该病历。
执行完任务后，权限自动撤销。

应用场景：

工作流系统、审批系统、临时授权操作（如 DevOps 自动化脚本）

5. OBAC（Object-Based Access Control）

基于对象的访问控制

核心特点：

访问控制依赖对象本身的属性和策略。
不看用户或角色，看“对象是否允许某类用户访问”。

举例：

一个文件设置了“仅允许创建者和其直属上级访问”，访问控制规则写在对象的元数据或策略中。
不依赖用户的角色或任务，只要对象规则允许，就能访问。

应用场景：

微服务架构、面向对象系统、基于资源策略的授权系统（如某些云平台）

总结对比表：

模型	控制基础	权限分配方式	粒度	动态性	上下文感知	安全性	灵活性	常见场景/系统
DAC	用户（资源拥有者）	手动分配	中	静态	低	低	高	Unix/Linux 文件系统、用户共享
MAC	系统策略/安全标签	统一策略控制	高	静态	中	很高	低	SELinux、军事系统、政府保密系统
RBAC	用户角色	基于角色分配	中	静态	中	高	中	企业权限管理、数据库、Kubernetes
TBAC	当前执行任务	任务自动授权	高	动态	高	高	中	工作流系统、临时任务授权、自动化系统
OBAC	对象自身策略	对象定义控制策略	非常高	动态或静态	高	高	高	云服务（如 AWS IAM）、微服务资源管理

E2_AES

Tue, 18 Mar 2025 13:09:22 +0800

算法主要原理

算法流程如下：

算法步骤

AES算法是一种对称分组密码算法，采用代换-置换网络（SPN）结构，通过多轮迭代的加密过程对数据进行混淆和扩散，确保其安全性。该算法将明文分成固定长度的128位数据块（实际上分组长度也有128位、192位或256位三种选择），并支持128位、192位或256位的密钥，分别对应10轮、12轮或14轮的加密轮次。每一轮加密过程包括四个核心操作：字节代换、行移位、列混淆和轮密钥加，其中最后一轮省略列混淆步骤。通过密钥扩展算法，初始密钥被扩展为多组轮密钥，供每一轮加密使用。AES算法的安全性依赖于其非线性的S盒变换、扩散层操作以及密钥的复杂性，使其能够有效抵抗线性攻击和差分攻击，成为当前最广泛使用的对称加密标准之一。

1.字节代换

字节代换是AES加密的核心非线性变换，它通过一个被称为S盒的查找表对状态矩阵中的每个字节进行独立替换。其中，S盒是经过精心设计的，它基于有限域GF(2⁸)上的乘法逆运算，再加上一个仿射变换，使得输出与输入之间不存在明显的数学关系。具体来说，每个字节先被看作GF(2⁸)中的元素，计算其乘法逆元（0x00映射到自身），然后经过一个固定的仿射变换。这种设计让S盒具备极强的非线性特性，有效抵抗线性密码分析。而解密过程则使用逆S盒进行反向替换，但这两个S盒并不是简单的互逆关系，而是各自独立构造的。

2.行移位

行移位步骤是对状态矩阵的行进行循环移位操作。具体来说，状态矩阵是一个4行4列的字节数组。第一行保持不变，第二行循环左移1个字节，第三行循环左移2个字节，第四行循环左移3个字节。这个操作使得原本在同一列中的字节被分散到不同列中。在解密时，需要进行相反方向的循环右移操作。行移位的目的是实现字节在状态矩阵中的扩散，使得后续的列混淆操作能更有效地传播变化。

3.列混淆

列混淆步骤对状态矩阵的每一列进行线性变换。该操作将每一列视为GF(2^8)上的多项式，与固定多项式进行有限域上的乘法。这个运算可以表示为矩阵乘法，其中每个字节的变换都是与固定系数的乘法和异或组合。

在实际实现中，这个步骤可以使用xtime进行化简。xtime定义为这样的一个函数，其输入是一个 8 位字节（即 GF(2⁸) 的元素），输出是该字节与 {02}（即多项式 x）相乘的结果，并在必要时进行模 x⁸ + x⁴ + x³ + x + 1（AES 使用的不可约多项式）的约简，也即异或0x1B。

在解密时，只需要变换固定系数矩阵即可。值得注意的是，最后一轮加密不包含列混淆操作。这个步骤增强了AES的扩散特性，使得单个字节的变化会影响整个列。

4.轮密钥加

轮密钥加步骤将当前轮的扩展密钥与状态矩阵进行简单的按位异或操作。每一轮都使用不同的轮密钥，这些密钥是通过密钥扩展算法从初始密钥派生出来的。这个操作是AES中唯一直接使用密钥的步骤。由于异或操作的可逆性，解密时只需使用相同的轮密钥再次异或即可恢复原始数据。这个步骤为算法提供了基于密钥的安全性。

5.密钥扩展算法

密钥扩展算法负责从初始密钥生成各轮所需的轮密钥。对于128位密钥，需要生成10个轮密钥（共44个32位字）。算法首先将初始密钥分成4个字（w[0]-w[3]），然后递归生成后续的字。我们这里只讨论128位密钥的扩展，其他位数的扩展步骤大致相同。

对于非4k个字，计算方式为前一个字w[i-1]与w[i-4]的简单异或（XOR）。每第4k个字（如w[4],w[8]等）需要特殊处理，计算方式为先对前一个字w[i-1]进行字节代换、循环移位，再与w[i-4]、轮常数异或。轮常数是一个与轮次相关的固定值，用于打破对称性。对于192位和256位密钥，扩展过程类似但细节略有不同。这个算法确保每个轮密钥都与前一个不同，且整个密钥调度具有足够的随机性。

6.DES与AES的对比

DES和AES在结构设计上采用了不同的密码学架构，体现了对称加密算法演进的思路。DES基于Feistel网络结构，这种结构将输入分组分为左右两部分，每轮只对其中一半进行加密变换，再通过交换左右部分实现数据混淆。Feistel结构的特点是加密解密过程对称，只需调整子密钥顺序即可实现逆向运算，这使得硬件实现相对简单。然而DES的56位密钥长度在计算能力提升后显得不足，且固定的S盒设计存在潜在的分析风险。

AES则采用了更为现代的SPN（Substitution-Permutation Network）结构，这种结构通过多轮重复的代换和置换操作实现数据加密。与Feistel网络不同，SPN结构在每一轮都对整个数据块进行完整的非线性变换和线性扩散。具体来说，AES的每轮加密都包含字节代换、行移位、列混淆和轮密钥加四个步骤，其中前三步分别实现非线性代换和线性扩散，最后一步引入密钥相关变换。这种设计使得AES在相同轮数下能实现更强的混淆和扩散效果。

从安全性角度来看，AES的SPN结构具有明显优势。其更大的分组长度（128位起）和可变的密钥长度（128/192/256位）能更好抵抗穷举攻击。每一轮对整个数据块的处理方式使得差分和线性分析更加困难，而DES的Feistel结构由于每轮只处理半块数据，需要更多轮数才能达到相似的混淆效果。此外，AES的S盒设计基于严密的数学理论，相比DES的固定S盒具有更强的抗分析能力。

在性能表现上，AES的SPN结构更适合现代计算环境。其算法设计充分考虑了软硬件实现的效率，在各类平台上都能展现出优异的性能。而DES由于其初始设计年代较早，在软件实现效率上相对较低，特别是在处理大数据量时更为明显。AES的轮数可以根据密钥长度灵活调整（10/12/14轮），在安全性和效率之间取得了更好的平衡。

NIST提出AES标准的主要原因在于DES已不能满足现代安全需求。随着计算能力的提升，DES的56位密钥面临被暴力破解的风险。1997年DES挑战赛被成功攻破，加速了新标准的制定进程。AES的选拔过程公开透明，最终Rijndael算法因其在安全性、性能和实现灵活性上的综合优势胜出。相比DES，AES提供了更高的安全强度、更优的执行效率以及更好的算法透明度，这些特点使其成为21世纪最重要的对称加密标准。

程序运行截图

参考代码

aes.py

# AES 128 bit encryption and decryption
# 128 bit 密钥 == 16 bytes == 32位十六进制
# 192 bit 密钥 == 24 bytes == 48位十六进制
# 256 bit 密钥 == 32 bytes == 64位十六进制

Sbox = (
 0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,
 0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,
 0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
 0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,
 0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,
 0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
 0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,
 0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,
 0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
 0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,
 0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,
 0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
 0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,
 0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,
 0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
 0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16,
)

InvSbox = (
 0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,
 0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,
 0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
 0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,
 0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,
 0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA, 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,
 0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,
 0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,
 0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
 0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,
 0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,
 0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
 0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,
 0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,
 0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
 0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D,
)

# xtime函数，用于有限域上的乘法运算
# 如果a的最高位为1，则左移1位后与0x1B异或，否则直接左移1位
# 0x1B 是 0001 1011 的十六进制表示，
# 0xFF 是 1111 1111 的十六进制表示，& 0xFF 运算只保留最低8位，其余位为0
# 0x80 是 1000 0000 的十六进制表示，& 0x80 运算只保留最高位，其余位为0
xtime = lambda a: (((a > (8 * (15 - i))) & 0xFF
 if i % 4 == 0:
 # 每4个字节开始一个新行
 matrix.append([byte])
 else:
 # 将字节添加到当前行
 matrix[int(i / 4)].append(byte)
 return matrix

def matrix2text(matrix):
 # 将矩阵转换为文本
 text = 0
 for i in range(4):
 for j in range(4):
 # 将每个字节移动到正确的位置并组合
 text |= (matrix[i][j] ![](/images/2025/03/image-11-1024x429.png)

## 参考资料

[bozhu/AES-Python: A pure Python implementation of AES](https://github.com/bozhu/AES-Python)

[AES - CTF Wiki](https://ctf-wiki.org/crypto/blockcipher/aes)

[密码学基础：AES加密算法 - 知乎](https://zhuanlan.zhihu.com/p/78913397)

E1_Vigenere

Tue, 18 Mar 2025 12:32:52 +0800

算法主要原理

加密公式：C = (P + K)%26

C：密文
P：原文
K：第几套加密方式

解密公式：P = (C - K)%26

C：密文
P：原文
K：第几套加密方式
如果P<0,P+26取得正序

简单来说，Vigenere密码实际上就是分组的凯撒密码。而分组的方法就是重复密钥，密钥相同的明文为同一组。每一组都可以看作是由不同的密钥所加密的凯撒密码。

算法步骤

加/解密

维吉尼亚密码是一种经典的多表替换加密算法，其改进了凯撒密码单表替换的弱点，通过使用不同的字母移位规则，使得频率分析攻击更加困难。

实际上可以将维吉尼亚密码理解为多个凯撒密码的加密，它的核心思想是用一个关键词来控制加密过程，使得同样的字母在明文的不同位置可能会被加密成不同的密文字母，这样就比简单的凯撒密码安全得多。

加密的时候就是把明文的每个字母按照密钥字母对应的数值进行移位，比如密钥字母A代表移0位（相当于不变），B移1位，一直到Z移25位。例如，当加密"HELLO"这个单词，选择的密钥是"KEY"，首先要把密钥重复到和明文一样长变成"KEYKE"，然后每个明文字母都对应一个密钥字母。然后每个字母加密时，H（在字母表里排第7位）对应K（排第10位），就往后移10位变成R（第17位）；E（第4位）对应E（第4位），移4位变成I（第8位）；第一个L（第11位）对应Y（第24位），11加24等于35，因为字母表只有26个字母，所以35减26得到9，对应J；第二个L（第11位）对应K（第10位），11加10等于21，对应V；O（第14位）对应E（第4位），14加4等于18，对应S。这样最终"HELLO"就被加密成了"RIJVS"。但要注意的是字母表是循环的，超过Z就要回到A继续算，所以计算时要取模26。

解密过程与加密过程相反，用密文字母和密钥字母相减，比如R（17位）减去K（10位）得到7对应H，I（8位）减E（4位）得到4对应E，以此类推。如果遇到字母相减得到负数的情况，把负数加上26就能得到正确的结果。

破解

维吉尼亚密码的核心安全特性来自于它的多表代换机制，但这也恰恰成为它被破解的突破口。要理解破解原理，我们需要先认清一个关键事实：维吉尼亚密码本质上是多个凯撒密码的交替使用。****

具体说来则是密钥长度决定了位移序列的长度，也即维吉尼亚密码是在循环应用一组固定的凯撒密码。若是我们确定了其密钥长度，则分组后的密码实际上呈现出单表特性，每组内部都是纯粹的凯撒密码，完全保留自然语言的统计特征。

因此破解维吉尼亚密码的重中之重是要破解出密钥长度，确定了密钥长度后就和破解凯撒密码无异了。所以说我们的破解步骤就分为确定密钥长度和确定密钥内容两步。

（一）确定密钥长度——重合指数法确定密钥长度

确定密钥长度这一步，我们采用重合指数法来确定。

因为对于正常的英语分布来说，从正常英语句子中随机取两个元素相同的概率是0.065，而如果是完全随机的字符串概率则是0.038。0.038~0.065之间的差距，让我们可以检验某一段文字是否符合正常的英语分布。

所以说，我们先假定密钥长度，便可以分出多组密文。每组密文内都是用相同的密钥加密的，因此只要是正常的、有意义的英文句子便符合0.065的概率。我们遍历可能的密钥长度，计算出接近0.065的值后取最小值就可以得到密钥长度。（当遍历的密钥长度稍长时，可能会出现真正密钥长度的倍数的IC会更接近0.065的情况，因此最好选容许的误差范围中的最小值）

以下是详细的数学证明过程：

（二）确定密钥内容——使用卡方检验确定密钥的内容

在确定密钥内容这一步，我们使用卡方检验来确定。

之前的步骤中我们已经将维吉尼亚密码转换为了多组凯撒密码。而对于凯撒密码来说，因为所有自然语言都存在特定的字母出现频率规律，单表替换加密虽然改变了字母的表象，但完整保留了这种统计特征。以英语为例，字母E的出现频率高达12.7%，T约9.1%，A约8.2%，这种分布特征就像语言的"指纹"一样稳定。当我们将明文通过凯撒密码加密时，整个字母表只是被整体平移了一定位数，比如位移3的情况下，原本高频的E会被统一替换成H，T变成W，A变成D，此时密文中H、W、D就会成为新的高频字母，它们与原始高频字母的对应关系完全由位移量决定。

那我们首先需要统计密文中各字母的出现频率，制作频率分布表，然后将这个统计结果与目标语言的标准字母频率进行对比匹配，这一步我们使用卡方检验。卡方检验可以通过量化比较两个字母频率分布的差异程度，来找出最可能使用的位移量。这个卡方值的计算公式是：将每个字母在解密文本中的观察频次与标准英语中的期望频次之差的平方除以期望频次后求和。卡方值越小，说明解密后的字母频率分布与标准英语越接近，也就意味着这个位移量越有可能是正确的密钥。求出密钥后，我们便可以轻松解密维吉尼亚密码了。

总结

破解Vigenere算法最主要就是两个步骤——确定密钥长度和确定密钥内容，而这两个步骤实际上都是利用了英语字母的分布规律来破解的，一个是通过重合指数，一个是通过卡方检验。

程序运行截图

参考代码

endecrypt.py

# Vigenere Cipher Encrypt/Decrypt

# 字母转数字
def L2N(L):
 return ord(L.upper()) - ord('A')

# 数字转字母
def N2L(N):
 return chr(N + ord('A'))

# 加密
def encrypt(text, key):
 encrypted_text = ''
 j=0
 for i in range(len(text)):
 if(text[i].isalpha()):
 encrypted_text += N2L((L2N(text[i]) + L2N(key[j%len(key)])) % 26)
 j+=1
 
 return encrypted_text
 
# 解密
def decrypt(text, key):
 decrypted_text = ''
 j=0
 for i in range(len(text)):
 decrypted_text += N2L((L2N(text[i]) - L2N(key[j%len(key)])) % 26)
 j+=1
 
 return decrypted_text

if __name__ == '__main__':
 text = 'I am alive here, my beloved, for the reason to adore you. Oh!How anxious I have been for you and how sorry I am about all you must have suffered in having no news from us. May heaven grant that this letter reaches you. Do not write to me, this would compromise all of us and above all,do not return under any circumstances. It is known that it was you who helped us to get away from here and all would be lost if you should show yourself.We are guarded day and night. I do not care you are not here. Do not be troubled on my account. Nothing will happen to me. The national assemble will show leniency. Farewell the most loved of men. Be quiet if you can take care of yourself.For myself I cannot write any more, but nothing in the world could stop me to adore you up to the death.'
 key = 'crypt'
 print(encrypt(text, key).lower())

crack.py

# Vigenere Cipher Crack
import math
import numpy as np
from typing import List, Tuple

def alpha(cipher: str) -> str:
 """
 预处理函数：去掉密文中的非字母字符（如空格、回车、标点符号等）。
 :param cipher: 密文字符串
 :return: 只包含字母的密文字符串
 """
 c = ""
 for char in cipher:
 if char.isalpha():
 c += char
 return c

def count_IC(cipher: str) -> float:
 """
 计算字符串的重合指数（IC）。
 :param cipher: 密文字符串
 :return: 重合指数值
 """
 count = [0] * 26
 L = len(cipher)
 IC = 0.0
 for char in cipher:
 if char.isupper():
 count[ord(char) - ord("A")] += 1
 elif char.islower():
 count[ord(char) - ord("a")] += 1
 for i in range(26):
 IC += (count[i] * (count[i] - 1)) / (L * (L - 1))
 return IC

def count_key_len(cipher: str, key_len: int) -> float:
 """
 对密文按密钥长度分组，并计算每组的平均重合指数。
 :param cipher: 密文字符串
 :param key_len: 密钥长度
 :return: 平均重合指数
 """
 groups = [""] * key_len
 IC = [0] * key_len
 for i in range(len(cipher)):
 m = i % key_len
 groups[m] += cipher[i]
 for i in range(key_len):
 IC[i] = count_IC(groups[i])
 print(f"长度为{key_len}时, 平均重合指数为{np.mean(IC):.5f}")
 return np.mean(IC)

def determine_key_length(cipher: str, tolerance: float = 0.01) -> int:
 """
 确定最可能的密钥长度。
 :param cipher: 密文字符串
 :param tolerance: 允许的重合指数误差范围
 :return: 最可能的密钥长度
 """
 possible_lengths = [] # 存储可能的密钥长度
 for key_len in range(1, 100): # 尝试密钥长度从1到100
 avg_IC = count_key_len(cipher, key_len)
 if abs(avg_IC - 0.065) int:
 """
 确定最可能的密钥长度。(老旧版本)
 :param cipher: 密文字符串
 :return: 最可能的密钥长度
 """
 key_len = 0
 min_diff = 100
 avg_IC = 0.0
 for i in range(1, 10):
 current_IC = count_key_len(cipher, i)
 if abs(current_IC - 0.065) float:
 """
 计算卡方统计量，用于评估解密后的文本是否符合英文字母频率分布。
 :param vec: 密文的子串（按密钥长度分组后的某一组）
 :param key: 尝试的密钥偏移量
 :return: 卡方统计量
 """
 freq = [0] * 26 # 统计字母频率
 for c in vec:
 if c.isalpha():
 c = c.lower()
 c = chr((ord(c) - ord("a") + (26 - key)) % 26 + ord("a"))
 freq[ord(c) - ord("a")] += 1

 # 英文字母的期望频率
 expected_freq = [
 0.08167,
 0.01492,
 0.02782,
 0.04253,
 0.12702,
 0.02228,
 0.02015,
 0.06094,
 0.06966,
 0.00153,
 0.00772,
 0.04025,
 0.02406,
 0.06749,
 0.07507,
 0.01929,
 0.00095,
 0.05987,
 0.06327,
 0.09056,
 0.02758,
 0.00978,
 0.02360,
 0.00150,
 0.01974,
 0.00074,
 ]

 # 确保期望频率的总和为1.0
 assert abs(1.0 - sum(expected_freq)) List[int]:
 """
 使用卡方检验确定每组最可能的相对偏移量。
 :param cipher: 密文字符串
 :param key_len: 密钥长度
 :return: 相对偏移量列表
 """
 possible_key = [] # 存储可能的密钥

 for i in range(key_len):
 # 生成当前分组的子串
 vec = [cipher[j] for j in range(i, len(cipher), key_len)]

 # 尝试所有可能的偏移量（0-25）
 possibility_array = []
 for j in range(26):
 curr_chi_square = chi_square(vec, j)
 possibility_array.append((chr(ord("a") + j), curr_chi_square))

 # 按卡方值从小到大排序（卡方值越小，可能性越大）
 possibility_array.sort(key=lambda x: x[1])

 # 选择卡方值最小的偏移量作为当前分组的密钥字母
 possible_key.append(ord(possibility_array[0][0]) - ord("a"))

 return possible_key

def decrypt(cipher: str, key_len: int, shifts: List[int]) -> str:
 """
 使用密钥对密文进行解密。
 :param cipher: 密文字符串
 :param key_len: 密钥长度
 :param shifts: 密钥字母的下标列表
 :return: 解密后的明文字符串
 """
 plain = ""
 i = 0
 while i str:
 """
 预处理函数：去掉密文中的非字母字符（如空格、回车、标点符号等）。
 :param cipher: 密文字符串
 :return: 只包含字母的密文字符串
 """
 c = ""
 for char in cipher:
 if char.isalpha():
 c += char
 return c

def count_IC(cipher: str) -> float:
 """
 计算字符串的重合指数（IC）。
 :param cipher: 密文字符串
 :return: 重合指数值
 """
 count = [0] * 26
 L = len(cipher)
 IC = 0.0
 for char in cipher:
 if char.isupper():
 count[ord(char) - ord("A")] += 1
 elif char.islower():
 count[ord(char) - ord("a")] += 1
 for i in range(26):
 IC += (count[i] * (count[i] - 1)) / (L * (L - 1))
 return IC

def count_key_len(cipher: str, key_len: int) -> float:
 """
 对密文按密钥长度分组，并计算每组的平均重合指数。
 :param cipher: 密文字符串
 :param key_len: 密钥长度
 :return: 平均重合指数
 """
 groups = [""] * key_len
 IC = [0] * key_len
 for i in range(len(cipher)):
 m = i % key_len
 groups[m] += cipher[i]
 for i in range(key_len):
 IC[i] = count_IC(groups[i])
 return np.mean(IC)

def determine_key_length(cipher: str, tolerance: float = 0.01) -> int:
 """
 确定最可能的密钥长度。
 :param cipher: 密文字符串
 :param tolerance: 允许的重合指数误差范围
 :return: 最可能的密钥长度
 """
 possible_lengths = [] # 存储可能的密钥长度
 IC_values = [] # 存储每个密钥长度对应的重合指数
 for key_len in range(1, 100): # 尝试密钥长度从1到100
 avg_IC = count_key_len(cipher, key_len)
 IC_values.append(avg_IC)
 if abs(avg_IC - 0.065) float:
 """
 计算卡方统计量，用于评估解密后的文本是否符合英文字母频率分布。
 :param vec: 密文的子串（按密钥长度分组后的某一组）
 :param key: 尝试的密钥偏移量
 :return: 卡方统计量
 """
 freq = [0] * 26 # 统计字母频率
 for c in vec:
 if c.isalpha():
 c = c.lower()
 c = chr((ord(c) - ord('a') + (26 - key)) % 26 + ord('a'))
 freq[ord(c) - ord('a')] += 1

 # 英文字母的期望频率
 expected_freq = [
 0.08167, 0.01492, 0.02782, 0.04253, 0.12702, 0.02228, 0.02015, 0.06094, 0.06966, 0.00153,
 0.00772, 0.04025, 0.02406, 0.06749, 0.07507, 0.01929, 0.00095, 0.05987, 0.06327, 0.09056,
 0.02758, 0.00978, 0.02360, 0.00150, 0.01974, 0.00074
 ]

 # 确保期望频率的总和为1.0
 assert abs(1.0 - sum(expected_freq)) Tuple[List[int], List[List[float]]]:
 """
 使用卡方检验确定每组与第一组之间的相对偏移量。
 :param cipher: 密文字符串
 :param key_len: 密钥长度
 :return: 相对偏移量列表和每一组的卡方值列表（未排序）
 """
 possible_key = [] # 存储可能的密钥
 chi_square_values = [] # 存储每一组的卡方值（未排序）

 for i in range(key_len):
 # 生成当前分组的子串
 vec = [cipher[j] for j in range(i, len(cipher), key_len)]

 # 尝试所有可能的偏移量（0-25）
 chi_values = [] # 存储当前分组的卡方值（未排序）
 for j in range(26):
 curr_chi_square = chi_square(vec, j)
 chi_values.append(curr_chi_square)

 # 按卡方值从小到大排序（卡方值越小，可能性越大）
 sorted_indices = np.argsort(chi_values) # 获取排序后的索引
 best_shift = sorted_indices[0] # 选择卡方值最小的偏移量

 # 存储结果
 possible_key.append(best_shift)
 chi_square_values.append(chi_values) # 存储未排序的卡方值

 return possible_key, chi_square_values

def decrypt(cipher: str, key_len: int, shifts: List[int]) -> str:
 """
 使用密钥对密文进行解密。
 :param cipher: 密文字符串
 :param key_len: 密钥长度
 :param shifts: 密钥字母的下标列表
 :return: 解密后的明文字符串
 """
 plain = ""
 i = 0
 while i < len(cipher):
 for j in range(key_len):
 if cipher[i].isupper():
 plain += chr(
 (ord(cipher[i]) - ord("A") - shifts[j] + 26) % 26 + ord("A")
 )
 else:
 plain += chr(
 (ord(cipher[i]) - ord("a") - shifts[j] + 26) % 26 + ord("a")
 )
 i += 1
 if i == len(cipher):
 break
 return plain

# GUI 界面
class VigenereCrackerApp:
 def __init__(self, root):
 self.root = root
 self.root.title("维吉尼亚密码工具")
 self.cipher = ""
 self.key_len = 0
 self.shifts = []
 self.plain = ""
 self.show_plots = tk.BooleanVar(value=True) # 是否展示柱状图

 # 创建选项卡
 self.notebook = ttk.Notebook(root)
 self.notebook.pack(fill="both", expand=True)

 # 添加“加/解密”选项卡
 self.add_encrypt_decrypt_tab()

 # 添加“破解”选项卡
 self.add_crack_tab()

 def add_encrypt_decrypt_tab(self):
 """添加加/解密选项卡"""
 tab = ttk.Frame(self.notebook)
 self.notebook.add(tab, text="加/解密")

 # 输入框
 input_label = ttk.Label(tab, text="原文：")
 input_label.grid(row=0, column=0, padx=10, pady=10, sticky="w")
 self.input_text_encrypt = tk.Text(tab, height=15, width=80)
 self.input_text_encrypt.grid(row=0, column=1, padx=10, pady=10)

 # 密钥输入框
 key_label = ttk.Label(tab, text="密钥：")
 key_label.grid(row=1, column=0, padx=10, pady=10, sticky="w")
 self.key_entry = ttk.Entry(tab, width=80)
 self.key_entry.grid(row=1, column=1, padx=10, pady=10, sticky="w")

 # 创建一个 Frame 来放置按钮
 button_frame = ttk.Frame(tab)
 button_frame.grid(row=2, column=0, columnspan=2, padx=10, pady=10)

 # 加密按钮
 encrypt_button = ttk.Button(button_frame, text="👇加密👇", command=self.encrypt_text)
 encrypt_button.pack(side="left", padx=10)

 # 解密按钮
 decrypt_button = ttk.Button(button_frame, text="👆解密👆", command=self.decrypt_text)
 decrypt_button.pack(side="left", padx=10)

 # 输出框
 output_label = ttk.Label(tab, text="密文：")
 output_label.grid(row=3, column=0, padx=10, pady=10, sticky="w")
 self.output_text_encrypt = tk.Text(tab, height=15, width=80)
 self.output_text_encrypt.grid(row=3, column=1, padx=10, pady=10)

 def add_crack_tab(self):
 """添加破解选项卡"""
 tab = ttk.Frame(self.notebook)
 self.notebook.add(tab, text="破解")

 # 输入框
 input_label = ttk.Label(tab, text="输入密文：")
 input_label.grid(row=0, column=0, padx=10, pady=10, sticky="w")
 self.input_text = tk.Text(tab, height=15, width=80)
 self.input_text.grid(row=0, column=1, padx=10, pady=10)

 # 输出框
 output_label = ttk.Label(tab, text="输出结果：")
 output_label.grid(row=1, column=0, padx=10, pady=10, sticky="w")
 self.output_text = tk.Text(tab, height=15, width=80)
 self.output_text.grid(row=1, column=1, padx=10, pady=10)

 # 按钮
 self.step1_button = ttk.Button(tab, text="1. 确定密钥长度", command=self.step1)
 self.step1_button.grid(row=2, column=0, padx=10, pady=10)

 self.step2_button = ttk.Button(tab, text="2. 确定密钥", command=self.step2)
 self.step2_button.grid(row=2, column=1, padx=10, pady=10)

 self.step3_button = ttk.Button(tab, text="3. 解密", command=self.step3)
 self.step3_button.grid(row=2, column=2, padx=10, pady=10)

 # 是否展示柱状图
 self.plot_check = ttk.Checkbutton(tab, text="展示柱状图", variable=self.show_plots)
 self.plot_check.grid(row=3, column=1, padx=10, pady=10)

 def encrypt_text(self):
 """加密文本"""
 text = self.input_text_encrypt.get("1.0", tk.END).strip() # 获取明文
 key = self.key_entry.get().strip() # 获取密钥
 if not text or not key:
 messagebox.showerror("错误", "请输入明文和密钥！")
 return
 encrypted_text = encrypt(text, key) # 调用加密函数
 self.output_text_encrypt.delete("1.0", tk.END) # 清空输出框
 self.output_text_encrypt.insert(tk.END, encrypted_text) # 显示密文

 def decrypt_text(self):
 """解密文本"""
 text = self.output_text_encrypt.get("1.0", tk.END).strip() # 获取密文
 key = self.key_entry.get().strip() # 获取密钥
 if not text or not key:
 messagebox.showerror("错误", "请输入密文和密钥！")
 return
 decrypted_text = decrypt_vigenere(text, key) # 调用解密函数
 self.input_text_encrypt.delete("1.0", tk.END) # 清空输入框
 self.input_text_encrypt.insert(tk.END, decrypted_text) # 显示明文

 def step1(self):
 """第一步：确定密钥长度"""
 self.cipher = alpha(self.input_text.get("1.0", tk.END).strip())
 try:
 self.key_len, IC_values = determine_key_length(self.cipher)
 self.output_text.delete("1.0", tk.END)
 self.output_text.insert(tk.END, f"密钥长度为: {self.key_len}\n")

 # 展示重合指数与密钥长度的图
 if self.show_plots.get():
 self.plot_IC_vs_keylen(IC_values)
 except ValueError as e:
 messagebox.showerror("错误", str(e))

 def step2(self):
 """第二步：确定密钥"""
 if not self.key_len:
 messagebox.showerror("错误", "请先确定密钥长度！")
 return

 # 调用 determine_relative_shifts 获取密钥和卡方值
 self.shifts, chi_square_values = determine_relative_shifts(self.cipher, self.key_len)
 self.output_text.insert(tk.END, f"相对偏移量: {self.shifts}\n")

 # 展示每一组的卡方与偏移量的图
 if self.show_plots.get():
 self.plot_chi_square_vs_shift(chi_square_values)

 def step3(self):
 """第三步：解密"""
 if not self.shifts:
 messagebox.showerror("错误", "请先确定密钥！")
 return
 self.plain = decrypt(self.cipher, self.key_len, self.shifts)
 self.output_text.insert(tk.END, f"解密后的明文: \n{self.plain}\n")

 def plot_IC_vs_keylen(self, IC_values):
 """绘制重合指数与密钥长度的柱状图"""
 fig, ax = plt.subplots()
 x = range(1, len(IC_values) + 1) # 横轴：密钥长度
 ax.bar(x, IC_values) # 绘制柱状图
 ax.set_xlabel("密钥长度")
 ax.set_ylabel("重合指数")
 ax.set_title("重合指数与密钥长度的关系")
 plt.show()

 def plot_chi_square_vs_shift(self, chi_square_values):
 """
 绘制每一组的卡方与偏移量的图。
 :param chi_square_values: 每一组的卡方值列表（未排序）
 """
 for i, chi_values in enumerate(chi_square_values):
 fig, ax = plt.subplots()
 x = range(26) # 横轴：偏移量（0-25）
 ax.bar(x, chi_values) # 绘制柱状图
 ax.set_xlabel("偏移量")
 ax.set_ylabel("卡方值")
 ax.set_title(f"分组 {i+1} 的偏移量与卡方值")
 plt.show()

# 运行 GUI
if __name__ == "__main__":
 root = tk.Tk()
 app = VigenereCrackerApp(root)
 root.mainloop()

参考资料

维吉尼亚密码的破解算法及python代码实现_维吉尼亚密码解密代码-CSDN博客

维吉尼亚密码产生密文，和密钥，如何得到明文? - 知乎

U2F相关疑问

Sun, 02 Mar 2025 17:16:08 +0800

本文为人工智能问答记录，内容仅供参考，可能存在错误信息。

这个服务器的名称若是攻击者伪造的，那不是照样没用吗，比如攻击者伪造成amazon.com

你提出了一个很好的问题！如果攻击者能够伪造服务器的名称（例如，将伪造的网站名称设置为 amazon.com），那么这种机制确实可能会失效。让我们深入分析一下这种情况，并解释为什么在实际应用中，这种攻击仍然可以被有效防范。

1. 服务器名称的真实性依赖于 HTTPS 和证书

在现代互联网中，网站的真实性是通过 HTTPS 和 SSL/TLS 证书 来验证的。
当用户访问 amazon.com 时，浏览器会检查该网站的 SSL/TLS 证书，确保证书是由受信任的证书颁发机构（CA）签发的，并且证书中的域名与用户访问的域名一致。
如果攻击者试图伪造 amazon.com，他们无法获取由受信任的 CA 签发的有效证书（除非他们攻破了 CA 或用户的系统），因此浏览器会显示警告，提示用户该网站不安全。

2. U2F 设备如何验证服务器名称

U2F 设备（如硬件密钥）在生成认证代码时，会检查用户正在访问的网站的真实性。
设备会通过浏览器的安全上下文获取网站的域名，并确保该域名与 SSL/TLS 证书中的域名一致。
如果攻击者伪造了 amazon.com，但由于没有有效的证书，U2F 设备会拒绝生成认证代码。

3. 攻击者伪造域名的难度

攻击者要成功伪造 amazon.com，需要满足以下条件：

获取有效的 SSL/TLS 证书：这几乎是不可能的，因为受信任的 CA 不会为攻击者签发 amazon.com 的证书。

绕过浏览器的安全机制：现代浏览器会严格检查证书的有效性，并阻止用户访问没有有效证书的网站。
欺骗 U2F 设备：U2F 设备会验证网站的真实性，攻击者无法欺骗设备生成针对伪造网站的代码。

4. 如果攻击者成功伪造域名会怎样？

如果攻击者通过某种方式成功伪造了 amazon.com（例如，通过 DNS 劫持或中间人攻击），U2F 设备可能会生成针对伪造网站的代码。
然而，这种攻击需要极高的技术能力，并且通常需要用户忽略浏览器的安全警告（例如“此网站不安全”）。
即使攻击者成功获取了针对伪造网站的代码，他们也无法使用该代码登录真实的 amazon.com，因为代码是与伪造网站绑定的。（有误）

总结

虽然理论上攻击者可以伪造服务器名称，但在实际应用中，这种攻击的难度非常高，且需要绕过多层安全机制（如 HTTPS、SSL/TLS 证书、浏览器安全检查和 U2F 设备的验证）。因此，这种基于服务器名称的认证机制仍然是一种有效的反钓鱼手段。

即使攻击者成功获取了针对伪造网站的代码，他们也无法使用该代码登录真实的 amazon.com，因为代码是与伪造网站绑定的。这句话有问题吧，如果攻击者把网站地址伪造成了amazon.com，生成的MAC(k,r∥amazon.com)不就可以正常登录了吗

你说得对！如果攻击者成功将网站地址伪造成 amazon.com，并且生成了 MAC(k, r∥amazon.com)，那么理论上这个代码是可以用于登录真实的 amazon.com 的。我的之前的解释确实不够准确，感谢你指出这一点！让我们重新分析这个问题，并更清晰地解释为什么这种攻击在实际中仍然难以成功。

1. 攻击者伪造 `amazon.com` 的难度

攻击者要成功伪造 amazon.com，需要满足以下条件：

域名伪造：攻击者需要通过某种方式（如 DNS 劫持或中间人攻击）将用户重定向到伪造的网站。

SSL/TLS 证书伪造：攻击者需要为伪造的网站获取有效的 SSL/TLS 证书，否则浏览器会显示安全警告，用户可能会察觉异常。
欺骗 U2F 设备：U2F 设备会验证网站的真实性，攻击者需要绕过这一机制。
如果攻击者成功伪造了 amazon.com，并且生成了 MAC(k, r∥amazon.com)，那么这个代码确实可以用于登录真实的 amazon.com，因为代码是与 amazon.com 绑定的。

2. 为什么这种攻击仍然难以成功

SSL/TLS 证书的保护：

现代网站使用 HTTPS，依赖于 SSL/TLS 证书来验证网站的真实性。

攻击者无法为 amazon.com 获取有效的 SSL/TLS 证书，除非他们攻破了受信任的证书颁发机构（CA）或用户的系统。
如果攻击者使用自签名证书或无效证书，浏览器会显示安全警告，提示用户该网站不安全。
U2F 设备的验证机制：

U2F 设备会通过浏览器的安全上下文获取网站的域名，并确保该域名与 SSL/TLS 证书中的域名一致。

如果攻击者伪造了 amazon.com，但由于没有有效的证书，U2F 设备会拒绝生成认证代码。
用户的安全意识：

现代浏览器会明确提示用户网站的安全性（例如，地址栏中的锁图标和“安全”字样）。

如果用户忽略浏览器的安全警告，攻击者可能会成功，但这需要用户主动配合。

3. 如果攻击者成功伪造 `amazon.com` 会怎样？

如果攻击者通过某种方式成功伪造了 amazon.com（例如，通过 DNS 劫持或中间人攻击），并且生成了 MAC(k, r∥amazon.com)，那么这个代码确实可以用于登录真实的 amazon.com。
然而，这种攻击需要极高的技术能力，并且通常需要用户忽略浏览器的安全警告。

4. 如何进一步防范这种攻击

使用更高级的认证机制：

例如，U2F 设备可以结合更多的上下文信息（如证书指纹或公钥）来验证网站的真实性。

提高用户的安全意识：

教育用户不要忽略浏览器的安全警告，并检查网站的 SSL/TLS 证书。

部署证书透明度（Certificate Transparency）：

这是一种公开日志系统，可以检测和防止恶意或错误签发的 SSL/TLS 证书。

总结

你提到的观点是正确的：如果攻击者成功伪造了 amazon.com，生成的 MAC(k, r∥amazon.com) 确实可以用于登录真实的 amazon.com。然而，这种攻击的难度非常高，需要绕过 HTTPS、SSL/TLS 证书和 U2F 设备的验证机制。因此，尽管理论上存在这种可能性，但在实际应用中，这种攻击仍然非常难以成功。

感谢你的指正！这让我更清晰地解释了这个问题。如果你有其他疑问，欢迎继续讨论！ 😊

PIN 和密码的区别

Sun, 02 Mar 2025 17:13:54 +0800

特性	PIN	密码
长度	4-6 位数字	至少 8 位，包含多种字符
复杂度	低（仅数字）	高（字母、数字、符号）
存储	通常存储在本地设备	通常存储在远程服务器上
用途	快速验证（如手机解锁、ATM）	高安全性场景（如银行账户）
安全性	较低，但通常与硬件绑定	较高，但依赖服务器安全性
用户体验	简单快捷	较复杂，可能需要密码管理器

Lec02-人员身份验证

Sun, 02 Mar 2025 17:09:30 +0800

由于时间精力有限，目前只翻译部分内容。本文使用人工智能协助翻译，内容仅供参考，可能有错误或遗漏。如果你对内容或超链接有疑问，可以查看原文。参考资料地址：https://github.com/PKUFlyingPig/MIT6.1600

1 认证

通常情况下，计算机系统在处理请求之前会执行两个步骤请求：

验证：识别发出请求的人或机器（“当事人”）。
授权：决定委托人是否有权提出请求。

2 密码（`Passwords`口令）

我们真正关心的是，对手将无法在少量的猜测中猜出你的密码。

理想情况下，我们希望从对手的角度来看所有密码的可能性都是相同的。但事实并非如此。人们必须记住自己的密码，结果很多人可能会选择相同的密码。

我们如何说服人类选择难以猜测的密码？

需要更长的密码？
禁止在密码中使用常用的英语单词吗？
强制更改密码？
是否要为该用户生成密码？

因此，尽管我们尽了最大努力，用户可能会选择简单的密码。为此，我们能做些什么呢？

2.1 处理糟糕的密码

一个“好”密码可能从一个大约20位熵的分布中采样。用目前的技术，猜测$2^{20}$次是很容易的。因此，当使用密码作为认证机制时，我们必须找到一种限制猜测的方法。

处理密码很容易猜测这一事实的一个标准方法是限制攻击者对密码的猜测次数。限制猜测的数量可以有效地防止单个账户被泄露——前提是密码不会太弱。一个缺点是猜测限制造成了拒绝服务攻击的可能性：攻击者可能会对你的密码进行10次猜测，并将你锁在你的手机或网上银行账户之外。

此外，在许多物理计算机系统中，都有多个授权用户，每个用户都有自己的密码。如果猜测限制只在每个用户的基础上强制执行，那么如果允许对每个用户的密码猜测10次，攻击者通常会破坏机器上的某些帐户。防止这些类型的攻击需要一些额外的措施：网站通过IP限制使用密码验证身份的速率，或使用验证码，等等。

2.2 存储密码

正如我们所看到的，密码很容易猜测，因此完全避免基于密码的身份验证是最安全的选择。

当系统必须使用密码进行身份验证时，存储密码的最安全的方法（例如，在服务器上）是使用加盐的加密密码哈希函数。其目标是根据存储在服务器上的哈希值，使攻击者尽可能难以恢复明文密码。

服务器选择一个随机的128位字符串，称为盐，并且服务器存储盐和哈希值 $h = H(salt∥pw)$ ，$H$ 是一个特殊的密码哈希函数。

然后，服务器存储一个像这样的表：

user	salt	$H(salt∥pw)$
alice	$r_a$	$h_a$
bob	$r_b$	$h_b$

同样，服务器可以使用盐和哈希函数来计算一个值 $h’=H（salt∥pw’）$ 。如果此散列值 $h’$ 与此用户的服务器存储值 $h$ 匹配，则服务器接受密码。

密码哈希函数H被为相对耗时的计算，这使得攻击者更难以强制反转哈希值，因为每次猜测密码都需要一秒钟的计算。（而不是计算标准哈希函数所需的微秒，比如SHA256）。
使用每个用户的随机盐，确保了对一个用户的密码的猜测在转换另一个用户的密码哈希时是无用的。加盐还可以击败预计算攻击，攻击者预先计算许多常见密码的哈希，以加速稍后的哈希反转步骤。

3 网络认证

到目前为止，我们一直在讨论人类对设备（ATM、电话、笔记本电脑等）进行手动身份验证，通过在设备中物理地输入PIN或密码。但是我们经常登录到网络上的一些服务器——Facebook、Gmail、MIT等等。在这个场景中，我们可以获取到更多身份验证机制和要求的安全属性。

3.1 密码管理器

当使用密码对网站进行身份验证时，用户可以在他们的计算机上安装一个密码管理器，从而为他们生成随机密码。由于用户不需要记住这些密码，它们可以从高熵分布中真正随机抽样。一旦用户登录到他们的电脑，他们就可以访问他们随机生成的密码，并使用它们登录到他们的网站。

但是基于密码的身份验证，即使有一个强大的密码，仍然需要通过网络发送密码。如果一个对手可以监视我们的网络，他们就可以看到我们的密码。我们稍后将讨论传输后安全，它可以防止网络窃听者，但更好的解决方案是在不通过网络发送密码的情况下进行身份验证。

3.2 挑战-响应协议

我们现在假设我们的计算机有一些密钥k（例如，一个随机的128位字符串），并且服务器也拥有相同的密钥k。

服务器选择一个长随机字符串r，我们通常称其为nonce，并将其发送给身份验证客户端。
客户端计算一个身份验证“标签”t←MAC（k，r），其中MAC（·，r）如果不知道k很难计算。（这里的函数MAC是一个消息认证码，我们将在？？中更具体地讨论它）将MAC标记t发送到服务器。
服务器从客户端接收到一个标签t‘，并确保t’=MAC（k，r）。如果是，则服务器认为身份验证已成功。

在实践中，客户端通常希望同时向服务器进行身份验证并发送请求请求，例如req= rm file.txt。为了实现这一点，客户端可以计算MAC标记t作为treq←MAC（k，r∥req），然后客户端将这对（treq，req）发送到服务器。通过这种方式，服务器可以同时对客户端进行身份验证，并确保请求请求来自客户端。

📝 Info

客户端同时向服务器进行身份验证并发送请求的一种不安全的方法是，客户端计算MAC标记t←MAC（k，r），然后向服务器发送（t，req）。网络攻击者可以在发送到服务器的途中将客户端的请求修改为（t，req‘），而服务器无法检测到此攻击。

4 双因素身份验证

正如我们已经看到的，密码是一种弱的身份验证机制：人类不擅长选择强密码，攻击者擅长窃取密码数据库，同时恢复许多用户的密码。

加强基于密码的身份验证系统的一种常见技术是将密码与第二种身份验证方法结合起来——一种具有不同的失败模式。常见的身份验证方案有：

一些你知道的东西：密码，PIN，等等
一些你有的东西： USB钥匙，电话，等等
一些你是的：生物识别技术（指纹，面部识别标识符）。。。

4.1 基于时间的一次性密码（TOTP）

在这种情况下，服务器会请求一个代码和密码。用户有一个设备，比如一个手机，它与服务器共享一个密钥k（例如，一个随机的128位字符串）。类似于MAC（k，gettimeofday()/30）。手机可以生成代码，并显示给用户，然后服务器可以通过重新计算代码来验证代码。

一个常见的攻击。 基于时间的一次性密码也是不完善的身份验证机制。例如，攻击者可以通过假装是技术支持人员、用户的雇主或客户服务代表，简单地要求用户给她提供一次性代码。这本质上是一种网络钓鱼攻击。然后代码可以持续30秒，所以攻击者就可以在网站的末端输入代码。类似的攻击还包括建立一个看起来像真实网站的假网站，等等。TOTP代码的一个好处（不像密码）是，攻击者必须在窃取后的30秒内使用被盗的TOTP代码，这需要更复杂的攻击。

📝 Info

网络钓鱼攻击是指攻击者欺骗用户泄露Gmail密码，例如，通过创建一个看起来像gmail.com登录页面的网站。

4.2 避免网络钓鱼：U2F（简化）

为了完全防止网络钓鱼攻击，我们可以使用一个更复杂的身份验证协议。如果我们在我们发送到该设备的请求中包含了用户试图登录到的服务器的名称，那么该代码将被绑定到一个特定的网站。例如，这些代码可能看起来有点像MAC（k，r∥amazon.com）。U2F密钥组数沿着这些线路使用一个协议来进行身份验证。如果攻击者设置了amason.com并让用户访问它，那么U2F设备将只生成一个适合amason.com的代码，而不是真正的amazon.com。

5 生物识别

生物识别学是一些物理特征，比如指纹、面部等。它们用于身份验证非常方便，因为您不会忘记它们，也不会轻易丢失它们。生物识别技术在亲自对设备进行身份验证时最有用，比如手机解锁，或授予用户访问安全保险库。在这些设置中，执行身份验证的设备有一个“可信的输入路径”，这可以提供一些保证，即拥有该生物特征的真人是在另一端。生物识别技术对于通过网络进行身份验证并不是那么有用，因为网络通常不提供可信的输入路径（也就是说，不提供任何生物识别读数来自真实的人类），而且生物识别数据本身也不是特别秘密。特别是，如果我们使用生物识别技术进行网络身份验证，一个知道你的指纹是什么样子的对手可以登录到你的账户。

Lec01-什么是安全？

Thu, 27 Feb 2025 15:12:55 +0800

本文使用人工智能协助翻译，内容仅供参考，可能有错误或遗漏。如果你对内容或超链接有疑问，可以查看原文。参考资料地址：https://github.com/PKUFlyingPig/MIT6.1600

6.1600课程团队：Henry Corrigan-Gibbs, Yael Kalai, Ben Kettle (TA), Nickolai Zeldovich 2022年秋季

⚠️ 免责声明

本套笔记为正在进行中的工作。其中可能存在错误，且缺少引用来源，内容亦不完整。如您发现任何错误，敬请告知工作人员。

1 概述

本课程的目的是向您介绍有关计算机系统安全的最重要的 “重要理念”。在整个课程中，我们将涉及计算机安全、密码学和（在一定程度上）计算机系统等领域的观点。

2 什么是安全？

安全是一个非常广泛的概念，但通常计算机安全的目标是确保某个计算机系统即使在面对试图破坏系统的“敌手”（或“攻击者”）时也能“正确运行”。

Info

在本课程中，我们将交替使用“敌手”和“攻击者”这两个术语。

为了实现这一目标，我们需要某种系统性的计划。也就是说，我们必须仔细定义系统“正确运行”的含义，并指定我们希望防御的“敌手”类别。

在本课程中，我们通常将计划分为三个部分：目标、威胁模型和实现。

目标：安全目标定义了我们希望系统实现的内容。例如，一个非正式的目标可能是“只有Alice可以读取文件F”，或者“如果有人篡改文件F，Alice将能够检测到”。正如您将在课程中学到的，确定您的安全目标究竟是什么通常是非常微妙且具有挑战性的。
威胁模型：威胁模型（或“敌手模型”）指定了我们希望防御的敌手类别。换句话说，威胁模型指定了敌手的能力：敌手在试图破坏我们的安全目标时可以做什么？通过定义威胁模型，我们可以使实现安全目标变得可行。例如，在分析基于密码的登录系统的安全性时，我们的威胁模型可能会指定敌手可以猜测密码，但不能窃取服务器。
实现：实现是我们如何实现目标。例如，我们可能会设置文件F的权限，使用Linux来强制执行这些权限，并要求双因素认证来访问系统。

Info

当你在新闻中读到安全漏洞时，值得尝试去理解这个漏洞是由于目标、威胁模型还是实现的问题引起的。

目标和威胁模型共同构成了我们对安全的定义。因此，它们不可能是“错误的”——目标可能最终并不完全符合我们的需求，威胁模型可能没有涵盖我们的系统在现实世界中可能面临的所有攻击，系统设计师在发现这一点时可能会感到惊讶，但目标和威胁模型共同定义了我们希望实现的安全属性。另一方面，实现肯定可能是错误的——如果由于错误、疏忽、供应链漏洞或其他任何原因，实现无法在威胁模型下保证目标，那么实现就存在错误。

2.1 安全是困难的

构建安全的系统是具有挑战性的。至少有两个广泛的原因。

首先，安全系统必须防御最坏情况下的行为。 安全系统必须防御威胁模型范围内的所有可能的攻击。相比之下，当我们只关注功能或正确性时，我们通常满足于一个在用户关心的场景下表现良好的系统。换句话说，安全关注的是最坏情况下的行为，而正确性通常关注的是预期情况下的行为。

Info

一些开发者确实会担心他们的系统在所有可能的输入和极端情况下的正确性；这种思维方式通常是确保安全性所必需的。

例如，假设我们有一个学生信息系统，其安全目标是：“只有助教可以访问成绩。” 测试随机抽取的助教是否可以访问成绩（正确性）很容易，但测试是否存在某种交互序列允许其他人访问成绩（安全性）则要困难得多。

其次，实现永远无法防御所有可能的威胁。 当我们指定威胁模型时，我们限定了实现必须防御的敌手集合。但现实世界中的敌手可能会以超出我们威胁模型的方式行事，从而破坏我们的安全目标。

例如，除了助教之外，其他人可能通过以下方式访问成绩：

发现服务器软件中的漏洞，
闯入助教的办公室，
入侵助教的笔记本电脑，
窃取管理员账户的密码，
诱骗助教泄露成绩，
破解服务器的加密，
在注册处找到工作并让自己成为助教。

这个列表永远不会结束。因为我们的威胁模型无法涵盖所有可能的威胁，安全永远不是完美的。几乎总是会有某些攻击者能够破坏您的系统。

这就是为什么我们需要威胁模型：威胁模型定义了我们需要担心的攻击类型，以及我们决定不在范围内的攻击类型。

2.2 设计安全目标和威胁模型

指定安全目标和威胁模型的核心在于比较防御攻击的成本与攻击发生时的成本。几乎不可能精确计算这些成本，但这个框架在概念上是有用的。能够阻止重大漏洞的廉价防御措施可能值得实施，但防御可能泄露不重要信息的射频（RF）侧信道攻击则可能不值得。

构建威胁模型总是需要迭代——您不会在第一次尝试时就做对。总会有一些您最初没有考虑到的攻击类型最终变得重要。

2.3 设计如何实现

在本课程中，我们将主要关注那些具有巨大回报的技术——开发软件和使用工具的方法，这些方法可以消除整个类别的攻击（或使它们变得更加困难）。

3 例子

我们给出了一些由于安全目标或威胁模型选择不当而导致的安全失败的例子。

3.1 错误的目标

商务舱机票。一家航空公司试图通过允许商务舱机票持有者随时免费更改机票（即出发日期、出发地和目的地）来增加其商务舱机票的价值。一位顾客意识到他们可以在登机后更改机票。然后，该顾客可以以一张机票的价格乘坐无限次商务舱航班。

在这种情况下，航空公司的目标并没有满足他们的实际需求——也许他们需要增加一个额外的目标，即“每次有人乘坐航班时，我们都会收到付款”。

莎拉·佩林的电子邮件。莎拉·佩林有一个雅虎电子邮件账户，雅虎使用安全问题来重置密码——他们的目标可能是“除非知道用户安全问题的所有答案，否则任何人都无法重置用户的密码。”（安全问题通常是诸如“您母亲的娘家姓是什么？”之类的问题。）事实证明，可以在互联网上找到佩林账户恢复安全问题的所有答案。¹雅虎的实现可能是完美的，但他们的目标并没有为某些用户提供任何有意义的安全性。

指令集架构（ISA）规范。在为处理器定义ISA时，设计者认为时间并不重要，处理器可以花费可变数量的周期来执行特定指令。这对性能和兼容性有很大的好处，但正如我们将在学期后面讨论的那样，研究人员最近利用这种时间可变性对广泛的处理器进行了复杂的攻击。²处理器的实现符合规范，但规范本身允许这种攻击。

复杂的访问控制策略。弗吉尼亚州费尔法克斯的一所学校使用了一个具有复杂访问控制结构的在线课程管理软件：每个教师负责一些班级，每个班级有许多学生，每个学生有许多文件。教师无法访问学生的文件，还有一个可以访问所有文件的校长。教师可以更改学生的密码，并可以将学生添加到他们的班级中。结果发现，教师可以将校长添加为学生，更改校长的密码，然后通过校长的账户访问所有文件。虽然每个访问控制策略单独听起来都合理，但它们共同导致了糟糕的结果。

Mat Honan的Gmail账户。一位名为Mat Honan的《连线》杂志记者的Gmail账户通过一次巧妙的攻击被攻破。³Honan有一个Gmail账户。Gmail的重置密码功能避免了使用安全问题，而是使用了一个备份电子邮件账户。攻击者触发了重置密码功能，该功能向Honan的Apple电子邮件账户发送了一个重置链接。

攻击者随后试图访问Honan的Apple电子邮件账户。攻击者触发了Apple账户的重置密码功能。Apple的重置密码功能需要Honan的地址和信用卡号码的最后四位数字。攻击者能够公开找到Honan的地址，但无法轻易找到他的信用卡号码。

攻击者通过Honan的Amazon账户找到了信用卡信息。Amazon知道他的信用卡号码，要求提供完整的信用卡号码才能重置账户。然而，Amazon允许在不登录的情况下为某个账户购买东西，只要提供一个新的信用卡号码。它还允许将这个新的信用卡号码保存到用户的Amazon账户中。因此，攻击者使用自己的信用卡在Amazon上进行了购买。然后，攻击者将自己的信用卡号码保存到Honan的Amazon账户中。接下来，攻击者触发了Amazon的重置密码功能，并使用保存到账户中的信用卡号码重置了Honan的Amazon密码并访问了他的Amazon账户。攻击者随后能够在Honan的Amazon账户中看到他真实信用卡的最后四位数字，使用这些数字重置了他的Apple邮件账户，然后使用该账户重置了Honan的Gmail账户。

像这样的复杂系统链可能非常难以推理，但这些交互最终对安全至关重要。

3.2 错误的威胁模型

假设特定策略：CAPTCHA。CAPTCHA被设计为通过自动化解决成本高昂，但人类易于阅读。确实，为CAPTCHA构建一个通用的光学字符识别系统可能成本高昂，但想要绕过CAPTCHA的攻击者并不这样做。相反，他们在劳动力成本低廉的国家建立了计算机中心。攻击者然后支付在这些中心工作的人员来解决CAPTCHA。⁴结果是，解决一个CAPTCHA的成本只有几分之一美分。解决CAPTCHA的成本仍然不为零，但成本远低于系统设计者可能预期的。

计算能力：DES。曾经有一个名为DES的加密标准，它有$2^{56}$个可能的密钥。在设计时，美国政府标准机构断言它甚至可以抵御强大的攻击者，但今天，现代计算机可以以适中的成本尝试所有$2^{56}$个密钥。（甚至在DES设计时，学术研究人员就明白56位密钥不足以防止穷举密码分析。⁵）

Info

例如，https://crack.sh/ 使用一组FPGA（现场可编程门阵列）来提供一种服务，该服务会穷举检查所有可能的密钥。

由于DES在现代计算机面前的弱点，所有使用该标准的人都必须升级他们的分组密码。例如，麻省理工学院不得不从使用DES进行身份验证转向使用具有更长密钥的更新分组密码，如AES。

依赖关系：通过短信的双因素认证（2FA）。许多2FA系统使用短信进行身份验证，但攻击者只需要说服AT&T商店的店员为您的电话号码提供一个新的SIM卡即可。

Info

这些攻击通常被称为“SIM交换”或“SIM劫持”。

软件版本：Xcode。iPhone应用程序通常在开发者的机器上创建和编译，发送到Apple的App Store，然后从那里发送到iPhone。iPhone应用程序是使用一个名为Xcode的工具创建的，该工具通常从Apple服务器下载。然而，Xcode是一个大型软件，对于中国防火墙后面的开发者来说，下载速度非常慢。中国境内的某人建立了一个更快的Xcode镜像，许多中国开发者使用了这个镜像中的Xcode版本。然而，这个镜像并没有提供Apple的Xcode版本——相反，它提供了一个稍微修改过的Xcode版本，该版本会在每个使用它编译的应用程序中注入一些恶意代码。这花了很长时间才被发现。

Info

维基百科上关于XcodeGhost的文章，https://en.wikipedia.org/wiki/XcodeGhost 提供了有关此攻击的更多详细信息。

3.3 有问题的实现

错误、配置错误和其他错误是安全问题的常见原因。一个经验法则是，每1000行代码大约会有1个错误。这是一个非常粗略的估计，但基本思想是代码越多，错误就越多。减少安全漏洞的有效策略是减少系统中的代码量。

缺少检查：iCloud。Apple的iCloud执行许多功能——电子邮件、日历、存储和“查找我的iPhone”。每个功能都有自己的登录方式，但在所有功能中，一个共同的目标是限制攻击者猜测用户密码的能力。为此，他们在所有登录界面中添加了速率限制，允许每小时只有10次登录尝试——但他们忘记了“查找我的iPhone”的登录界面。⁶由于这些认证代码在多个地方重复，有许多地方需要记住添加速率限制，但攻击者只需要一个薄弱的登录界面就可以暴力破解密码。一般来说，避免这种重复将使构建安全系统变得更加容易。

不安全的默认设置。当您设置新服务时，它们几乎总是带有一些默认设置以简化设置。Wi-Fi路由器带有默认密码，AWS S3存储桶带有默认权限，等等。这些默认设置可能很方便，但它们对安全非常重要，因为许多人会忘记或忽略更改默认设置。因此，默认设置成为系统的操作方式。为了构建一个安全的系统，重要的是默认设置是安全的。

4. 安全系统设计的一般原则是什么？

4.1 目标和威胁模型

创建简单、通用的目标。
通过更好的设计避免假设（例如“没有人能够获得用户的SIM卡”）。
学习并迭代。
实践深度防御：不要依赖单一的防御措施来保护所有安全——使用备用防御措施来防范不可避免的错误是很有用的。

4.2 实现

更简单的系统会带来更少的问题。
将安全关键部分分解为一个小的独立系统或代码片段（例如，硬件安全密钥）。
重用设计良好的代码，例如经过良好测试的加密库。
理解并测试极端情况。

参考文献

Diffie, Whitfield and Martin E. Hellman. “Exhaustive Cryptanalysis of the NBS Data Encryption Standard”. In: Computer 6.10 (1977), pp. 74–84.
Hill, Mark D. et al. “On the Spectre and Meltdown Processor Security Vulnerabilities”. In: IEEE Micro 39.2 (2019), pp. 9–19.
Honan, Mat. How Apple and Amazon Security Flaws Led to My Epic Hacking. https://www.wired.com/2012/08/apple-amazon-mat-honan-hacking/. Aug. 2012.
Motoyama, Marti et al. “Re: CAPTCHAs—Understanding CAPTCHASolving Services in an Economic Context”. In: Proceedings of the 19th USENIX Security Symposium. Washington, DC, Aug. 2010.
Trew, J. ‘Find My iPhone’ exploit may be to blame for celebrity photo hacks (update). https://www.engadget.com/2014-09-01-find-my-iphone-exploit.html. Sept. 2014.
Zetter, Kim. Palin e-mail hacker says it was easy. https://www.wired.com/2008/09/palin-e-mail-ha/. Sept. 2008.

Kim Zetter. Palin e-mail hacker says it was easy. https://www.wired.com/2008/09/palin-e-mail-ha/. Sept. 2008. ↩︎
Mark D. Hill et al. “On the Spectre and Meltdown Processor Security Vulnerabilities”. In: IEEE Micro 39.2 (2019), pp. 9–19. ↩︎
Mat Honan. How Apple and Amazon Security Flaws Led to My Epic Hacking. https://www.wired.com/2012/08/apple-amazon-mat-honan-hacking/ . Aug. 2012. ↩︎
Marti Motoyama et al. “Re:CAPTCHAs—Understanding CAPTCHA-Solving Services in an Economic Context”. In: Proceedings of the 19th USENIX Security Symposium. Washington, DC, Aug. 2010. ↩︎
Whitfield Diffie and Martin E. Hellman. “Exhaustive Cryptanalysis of the NBS Data Encryption Standard”. In: Computer 6.10 (1977), pp. 74–84. ↩︎
J. Trew. ‘Find My iPhone’ exploit may be to blame for celebrity photo hacks (update). https://www.engadget.com/2014-09-01-find-my-iphone-exploit.html . Sept. 2014. ↩︎

信息安全 on 蛋蛋忧桑

访问控制策略

1. DAC（Discretionary Access Control）

核心特点：

举例：

类似系统：

2. MAC（Mandatory Access Control）

核心特点：

举例：

类似系统：

3. RBAC（Role-Based Access Control）

核心特点：

举例：

类似系统：

4. TBAC（Task-Based Access Control）

核心特点：

举例：

应用场景：

5. OBAC（Object-Based Access Control）

核心特点：

举例：

应用场景：

总结对比表：

E2_AES

算法主要原理

算法步骤

1.字节代换

2.行移位

3.列混淆

4.轮密钥加

5.密钥扩展算法

6.DES与AES的对比

程序运行截图

参考代码

aes.py

E1_Vigenere

算法主要原理

算法步骤

加/解密

破解

（一）确定密钥长度——重合指数法确定密钥长度

（二）确定密钥内容——使用卡方检验确定密钥的内容

总结

程序运行截图

参考代码

endecrypt.py

crack.py

参考资料

U2F相关疑问

这个服务器的名称若是攻击者伪造的，那不是照样没用吗，比如攻击者伪造成amazon.com

1. 服务器名称的真实性依赖于 HTTPS 和证书

2. U2F 设备如何验证服务器名称

3. 攻击者伪造域名的难度

4. 如果攻击者成功伪造域名会怎样？

总结

1. 攻击者伪造 amazon.com 的难度

2. 为什么这种攻击仍然难以成功

3. 如果攻击者成功伪造 amazon.com 会怎样？

4. 如何进一步防范这种攻击

总结

PIN 和密码的区别

Lec02-人员身份验证

1 认证

2 密码（Passwords口令）

2.1 处理糟糕的密码

2.2 存储密码

3 网络认证

3.1 密码管理器

3.2 挑战-响应协议

4 双因素身份验证

4.1 基于时间的一次性密码（TOTP）

4.2 避免网络钓鱼：U2F（简化）

5 生物识别

Lec01-什么是安全？

1 概述

2 什么是安全？

2.1 安全是困难的

2.2 设计安全目标和威胁模型

2.3 设计如何实现

3 例子

1. 攻击者伪造 `amazon.com` 的难度

3. 如果攻击者成功伪造 `amazon.com` 会怎样？

2 密码（`Passwords`口令）