原始文件
   ↓  AES-256-CBC 加密（密钥 = 随机生成的 FEK）
加密后的文件内容

FEK（256 位随机数）
   ↓  RSA-2048 加密（密钥 = 用户的 EFS 公钥）
加密后的 FEK

┌─────────────────────────────────────────────┐
│  NTFS 加密文件                                │
│                                               │
│  ┌─────────────────────────────────────────┐ │
│  │  $EFS 元数据流                           │ │
│  │  • RSA 公钥 (n, e)                      │ │
│  │  • 加密后的 FEK = FEK^e mod n           │ │
│  │  • EFS 证书指纹                          │ │
│  │  • AES-CBC 的 IV（初始向量）              │ │
│  └─────────────────────────────────────────┘ │
│                                               │
│  ┌─────────────────────────────────────────┐ │
│  │  加密后的文件内容（AES-256-CBC 密文）      │ │
│  └─────────────────────────────────────────┘ │
└─────────────────────────────────────────────┘

经典计算机（GNFS 算法）：~10^30 年  ❌
量子计算机（Shor 算法）：~几小时     ✅

d = e^(-1) mod φ(n)
其中 φ(n) = (p-1)(q-1)

FEK_padded = C^d mod n

[0x00] [0x02] [至少 8 字节随机非零填充] [0x00] [FEK 原文]

明文 = AES-256-CBC-Decrypt(密文, FEK, IV)
去掉末尾 PKCS#7 填充

磁盘上的加密文件
       │
       ├── $EFS 元数据 ──→ 提取 RSA 公钥 (n, e) 和 IV
       │                      │
       │                      ↓
       │                 量子计算机 Shor 算法
       │                      │
       │                      ↓
       │                 分解 n = p × q
       │                      │
       │                      ↓
       │                 计算私钥 d = e^(-1) mod (p-1)(q-1)
       │                      │
       ├── 加密的 FEK ───→ RSA 解密：FEK_padded = C^d mod n
       │                      │
       │                      ↓
       │                 PKCS#1 v1.5 填充验证
       │                      │
       │                      ↓
       │                 提取原始 FEK（256 位）
       │                      │
       └── 加密的文件内容 ──→ AES-256-CBC 解密（FEK + IV）
                              │
                              ↓
                         原始文件 ✅

第 1 步：多项式选择
━━━━━━━━━━━━━━━━━
选择一个不可约多项式 f(x) 和整数 m，使得 f(m) ≡ 0 (mod n)。
这定义了一个代数数域 Q(θ)，其中 θ 是 f(x) 的根。
→ 本质上是在有理数域和代数数域之间建立桥梁。


第 2 步：筛法（最耗时）
━━━━━━━━━━━━━━━━━━━
在预定义范围内搜索大量整数对 (a, b)，使得：
  • a + bm 在有理数域中是"B-平滑的"（所有素因子 ≤ B）
  • a + bθ 在代数数域中对应的范数也是平滑的

平滑：一个数的所有质因数都很小（不超过某个界限 B）
→ 这一步需要分布式计算，是算法的主要瓶颈。


第 3 步：线性代数
━━━━━━━━━━━━━━
将收集到的平滑关系构造为一个巨大的稀疏矩阵（mod 2）。
求解该矩阵的零空间，找到一组关系，使乘积在两个域中同时为完全平方。
→ 矩阵规模可达数亿行列，需要专门的稀疏矩阵算法（Block Lanczos）。


第 4 步：平方根计算
━━━━━━━━━━━━━━━━
利用上一步的解，分别在有理数域和代数数域中计算平方根，
得到 s 和 r，满足 s² ≡ r² (mod n)。


第 5 步：分解
━━━━━━━━━━━
计算 gcd(s - r, n)，大概率得到 n 的一个非平凡因子。
如果失败（得到 1 或 n），调整参数重新运行。

L(n) = exp( (64/9)^(1/3) · (ln n)^(1/3) · (ln ln n)^(2/3) )

第 1 步：经典预处理
━━━━━━━━━━━━━━━━
随机选择整数 y，1 < y < n
计算 gcd(y, n)：
  • 若 gcd(y, n) > 1 → 直接分解成功（运气好）
  • 若 gcd(y, n) = 1 → 进入量子阶段


第 2 步：构造量子叠加态
━━━━━━━━━━━━━━━━━━━
准备两个量子寄存器：
  输入寄存器：|0⟩ + |1⟩ + |2⟩ + ... + |Q-1⟩ （Q ≈ n² 的叠加态）
  输出寄存器：|0⟩

对输入寄存器的每个值 x，计算 f(x) = y^x mod n，存入输出寄存器。

→ 此时系统处于纠缠态：
  |0, y^0 mod n⟩ + |1, y^1 mod n⟩ + |2, y^2 mod n⟩ + ...

关键：这一步在量子计算机上是并行的，所有 Q 个值同时计算。
经典计算机只能逐个算，这就是量子加速的本质。


第 3 步：量子傅里叶变换（QFT）
━━━━━━━━━━━━━━━━━━━━━━━━━━
对输入寄存器施加逆量子傅里叶变换（iQFT）。

QFT 的作用：将"时域"的叠加态转换为"频域"。
由于 f(x) = y^x mod n 是周期函数（周期为 r），
QFT 后，输入寄存器的测量值会集中在 r 的整数倍附近。

→ 类比：就像对一段周期性信号做傅里叶变换，频谱上会出现尖峰。


第 4 步：测量与经典后处理
━━━━━━━━━━━━━━━━━━━━
测量输入寄存器，得到一个值 c ≈ k·Q/r（k 为某个整数）。

用连分数算法从 c/Q 中提取周期 r：
  c/Q ≈ k/r → 用连分数展开逼近，得到 r

如果 r 为偶数且 y^(r/2) ≢ -1 (mod n)：
  因子 p = gcd(y^(r/2) - 1, n)
  因子 q = gcd(y^(r/2) + 1, n)
  → 分解成功 ✅

如果不满足条件 → 换一个 y，重复以上步骤。
成功概率 ≥ 50%，重复几次几乎必然成功。

经典计算机求周期 r：
  逐个计算 y^1 mod n, y^2 mod n, y^3 mod n, ...
  直到 y^r ≡ 1 (mod n)
  → r 可能大到 ~n，即 ~2^2048，逐个算不可行

量子计算机求周期 r：
  利用叠加态，同时计算所有 y^x mod n
  → 然后用 QFT 一次性提取周期信息
  → 总操作次数 ~O(log³n)，即多项式级