编程 Apple CoreCrypto 开源深度解析：后量子密码学的形式化验证革命

2026-05-31 09:25:15 +0800 CST views 9

Apple CoreCrypto 开源深度解析：后量子密码学的形式化验证革命

引言：为什么苹果突然开源「抗量子」代码？

2026年5月22日，苹果安全工程与架构团队（SEAR）和硬件技术形式化验证团队做出了一件打破常规的事——将 corecrypto 密码学库的后量子密码学（PQC）实现完整开源，包括 ML-KEM、ML-DSA 算法的源代码、测试工具、性能基准，以及最关键的形式化验证证明。

这颗「炸弹」为什么现在引爆？

量子威胁的倒计时已经开始。 2024年，NIST 正式发布后量子密码学标准 FIPS 203（ML-KEM）和 FIPS 204（ML-DSA），标志着全球密码学基础设施的代际迁移正式启动。传统 RSA、ECC 算法在量子计算机面前将变得不堪一击——Shor 算法可以在多项式时间内破解这些广泛使用的公钥密码体系。

苹果的选择是：不仅要实现，还要用数学证明实现的正确性。

本文将深入剖析 Apple CoreCrypto 的后量子密码学实现架构、形式化验证方法论，以及如何在生产环境中安全落地这些「抗量子」算法。

一、后量子密码学：从理论到实战的跨越

1.1 量子计算机为何威胁现有密码学？

要理解后量子密码学的紧迫性，先得搞清楚量子计算机对现有密码体系的具体威胁。

传统公钥密码学的数学根基：

算法类型	数学难题	经典计算机破解复杂度	量子计算机破解复杂度
RSA	大整数分解	$O(e^{n^{1/3}})$ 亚指数级	$O(n^3)$ 多项式级
ECC	椭圆曲线离散对数	$O(\sqrt{n})$ 指数级	$O(n^3)$ 多项式级
DSA	离散对数问题	$O(\sqrt{n})$ 指数级	$O(n^3)$ 多项式级

Shor 算法的核心在于利用量子傅里叶变换（QFT）高效求解周期问题，而整数分解和离散对数问题都可以转化为周期问题的特例。一台足够强大的量子计算机——估计需要数百万逻辑量子比特——可以在几小时内破解当前广泛使用的 2048 位 RSA 密钥或 256 位 ECC 曲线。

「现在窃取，未来解密」攻击：

更现实的威胁是「Harvest Now, Decrypt Later」攻击模式。攻击者可以：

今天截获并存储加密流量
等待量子计算机成熟
批量解密历史数据

这意味着，如果你的数据需要保密10年以上，你今天就应该使用后量子密码学保护它。

1.2 NIST 后量子密码学标准：ML-KEM 与 ML-DSA

经过长达8年的全球竞赛，NIST 在2024年正式标准化了两种后量子算法：

ML-KEM（FIPS 203）：Module-Lattice-Based Key-Encapsulation Mechanism

用途：密钥交换、密钥封装
数学基础：模块格（Module Lattice）上的 Learning With Errors（LWE）问题
安全等级：ML-KEM-512（128位）、ML-KEM-768（192位）、ML-KEM-1024（256位）
公钥大小：ML-KEM-768 约 1184 字节
密文大小：ML-KEM-768 约 1088 字节

ML-DSA（FIPS 204）：Module-Lattice-Based Digital Signature Algorithm

用途：数字签名、身份认证
数学基础：模块格上的 Fiat-Shamir 变体
安全等级：ML-DSA-44（128位）、ML-DSA-65（192位）、ML-DSA-87（256位）
公钥大小：ML-DSA-65 约 1952 字节
签名大小：ML-DSA-65 约 3293 字节

与传统算法相比，后量子算法的密钥和签名确实更大：

算法	公钥大小	签名/密文大小
RSA-2048	256 字节	256 字节
ECDSA P-256	64 字节	64 字节
ML-KEM-768	1184 字节	1088 字节
ML-DSA-65	1952 字节	3293 字节

这种「膨胀」是量子安全的代价，但现代网络带宽完全可以承受。

1.3 格密码学：后量子时代的数学基石

ML-KEM 和 ML-DSA 都基于格密码学（Lattice-based Cryptography）。理解格的概念对掌握后量子算法至关重要。

什么是格（Lattice）？

数学上，格是 $\mathbb{R}^n$ 空间中向量的离散子群。给定一组线性无关的基向量 $\mathbf{B} = {\mathbf{b}_1, \ldots, \mathbf{b}_n}$，格定义为：

$$\mathcal{L}(\mathbf{B}) = \left{ \sum_{i=1}^{n} a_i \mathbf{b}_i \mid a_i \in \mathbb{Z} \right}$$

格密码学的安全性依赖于格上「困难问题」的计算复杂度：

Shortest Vector Problem（SVP）：给定格 $\mathcal{L}$，找到最短的非零向量。

Learning With Errors（LWE）：给定 $(\mathbf{A}, \mathbf{b} = \mathbf{A}\mathbf{s} + \mathbf{e})$，其中 $\mathbf{A}$ 是随机矩阵，$\mathbf{s}$ 是秘密向量，$\mathbf{e}$ 是小误差向量，求解 $\mathbf{s}$。

LWE 问题被证明可以归约到格上最坏情况困难问题，这意味着：

如果存在多项式时间算法求解 LWE，则可以对所有格高效求解 SVP
目前没有已知的多项式时间量子算法可以高效求解 LWE

ML-KEM 的核心运算（简化版）：

# ML-KEM 密钥生成（简化示意）
def ml_kem_keygen():
    # 生成随机矩阵 A ∈ Z_q^{k×k}
    A = random_matrix(k, k, modulus=q)
    # 生成秘密向量 s 和误差向量 e
    s = sample_small_vector(k)
    e = sample_small_vector(k)
    # 公钥：t = A·s + e
    t = matrix_vector_mult(A, s) + e
    return (public_key=(A, t), secret_key=s)

# ML-KEM 封装（简化示意）
def ml_kem_encapsulate(public_key):
    A, t = public_key
    # 生成随机向量 r, e1, e2
    r = sample_small_vector(k)
    e1 = sample_small_vector(k)
    e2 = sample_small_error()
    # 计算共享密钥
    u = matrix_vector_mult(A.T, r) + e1  # 密文第一部分
    v = inner_product(t, r) + e2         # 密文第二部分
    # 派生共享密钥
    K = hash(u, v)
    return (ciphertext=(u, v), shared_key=K)

二、Apple CoreCrypto 架构深度解析

2.1 CoreCrypto 在 Apple 安全生态中的定位

corecrypto 是 Apple 操作系统底层的密码学原语库，支撑着：

┌─────────────────────────────────────────────────────────────┐
│                    Application Layer                        │
│  iMessage | Secure Enclave | iCloud | Apple Pay | Safari   │
├─────────────────────────────────────────────────────────────┤
│                    High-Level APIs                          │
│         CryptoKit | Security.framework | CommonCrypto       │
├─────────────────────────────────────────────────────────────┤
│                    CoreCrypto (核心层)                       │
│   AES | ChaCha20 | SHA-2/3 | RSA | ECC | ML-KEM | ML-DSA   │
├─────────────────────────────────────────────────────────────┤
│                    Hardware Acceleration                    │
│        Secure Enclave | AES Engine | Memory Controller      │
└─────────────────────────────────────────────────────────────┘

关键特性：

零依赖：不依赖任何外部库，所有密码学原语自实现
跨平台：iOS、macOS、watchOS、tvOS、visionOS 统一实现
硬件加速：自动利用 Apple Silicon 的专用密码学指令
形式化验证：关键算法经过 Coq/Lean 数学证明

2.2 开源仓库结构解析

Apple 在 GitHub 上发布的 corecrypto 仓库包含以下核心目录：

corecrypto/
├── src/
│   ├── ccmlkem/          # ML-KEM 实现
│   │   ├── mlkem.c       # 核心算法
│   │   ├── mlkem_encaps.c
│   │   ├── mlkem_decaps.c
│   │   └── mlkem_poly.c  # 多项式运算
│   ├── ccmldsa/          # ML-DSA 实现
│   │   ├── mldsa.c
│   │   ├── mldsa_sign.c
│   │   └── mldsa_verify.c
│   └── fips/             # FIPS 合规性验证
├── formal_verification/
│   ├── coq/              # Coq 证明
│   │   ├── MLKEM/        # ML-KEM 形式化验证
│   │   └── MLDSA/        # ML-DSA 形式化验证
│   └── extraction/       # 代码提取
├── test/
│   ├── kat/              # Known Answer Tests
│   ├── vectors/          # 测试向量（NIST 官方）
│   └── performance/      # 性能基准
└── tools/
    ├── build.sh          # 构建脚本
    └── benchmark.sh      # 性能测试

2.3 ML-KEM 实现核心代码解析

让我们深入分析 mlkem_encaps.c 的关键实现：

// ML-KEM-768 封装核心函数（简化版，保留算法逻辑）
int mlkem_encaps(const uint8_t *pk, uint8_t *ct, uint8_t *ss) {
    // 步骤1：从公钥解析矩阵 A 和向量 t
    mlkem_polyvec matrixA[KYBER_K];
    mlkem_polyvec vectort;
    mlkem_polyvec vectorb;
    
    // 解析公钥（Packed 格式 → Polynomial 格式）
    unpack_pk(matrixA, &vectort, pk);
    
    // 步骤2：采样随机向量 r、误差向量 e1、e2
    mlkem_polyvec vectorr, vectore1;
    mlkem_poly polye2;
    
    // 使用 CBD（Centered Binomial Distribution）采样
    poly_getnoise_eta1(&vectorr, seed, nonce++);
    poly_getnoise_eta1(&vectore1, seed, nonce++);
    poly_getnoise_eta2(&polye2, seed, nonce++);
    
    // 步骤3：计算密文第一部分 u = A^T · r + e1
    // 使用 NTT（Number Theoretic Transform）加速多项式乘法
    polyvec_ntt(&vectorr);
    matrix_vector_mul(&vectorb, matrixA, &vectorr, 1); // 矩阵-向量乘
    polyvec_invntt_tomont(&vectorb);
    polyvec_add(&vectorb, &vectorb, &vectore1);
    
    // 步骤4：计算密文第二部分 v = t^T · r + e2 + encode(m)
    polyvec_basemul_acc_montgomery(&polyv, &vectort, &vectorr);
    poly_invntt_tomont(&polyv);
    poly_add(&polyv, &polyv, &polye2);
    
    // 步骤5：编码共享密钥
    encode_ciphertext(ct, &vectorb, &polyv);
    
    // 步骤6：派生共享密钥（KDF）
    hash_h(ss, ct, KYBER_CIPHERTEXTBYTES);
    sha3_256(ss, ss, 32);
    
    return 0;
}

关键技术细节：

NTT 加速：多项式乘法从 $O(n^2)$ 降到 $O(n \log n)$
拒绝采样：确保采样分布正确
常量时间实现：防止侧信道攻击

// 常量时间比较（防侧信道）
int cmov_uint8(uint8_t *r, const uint8_t *x, size_t len, uint8_t b) {
    size_t i;
    b = -b;  // 0 → 0x00, 1 → 0xFF
    for (i = 0; i < len; i++) {
        r[i] ^= b & (r[i] ^ x[i]);
    }
    return 0;
}

2.4 性能优化：从理论到实测

Apple 在 M4 芯片上对 ML-KEM 进行了深度优化：

操作	ML-KEM-512	ML-KEM-768	ML-KEM-1024
密钥生成	12,400 cycles	18,900 cycles	26,100 cycles
封装	14,200 cycles	21,500 cycles	29,800 cycles
解封装	15,100 cycles	22,800 cycles	31,500 cycles

换算成实际延迟（M4 @ 3.5GHz）：

ML-KEM-768 密钥生成：~5.4 微秒
ML-KEM-768 封装：    ~6.1 微秒
ML-KEM-768 解封装：  ~6.5 微秒

对比传统算法：

算法	密钥生成	封装/加密	解封装/解密
RSA-2048	~1,000,000 cycles	~200,000 cycles	~50,000 cycles
ECDH P-256	~300,000 cycles	~600,000 cycles	~300,000 cycles
ML-KEM-768	~18,900 cycles	~21,500 cycles	~22,800 cycles

结论：ML-KEM 在性能上碾压传统公钥算法。

三、形式化验证：用数学证明代码正确性

3.1 为什么形式化验证如此重要？

传统软件测试存在一个根本性局限：测试只能发现 bug，不能证明没有 bug。

对于密码学实现，这个局限是致命的：

边界条件难以穷举：密码学算法涉及大量边界情况
侧信道攻击隐蔽：时序攻击、功耗分析难以通过测试发现
数学正确性：实现必须与数学规范完全一致

Apple 选择的形式化验证方法是：将代码和数学规范都转化为数学公式，然后用证明器推导验证两者等价。

┌─────────────────┐     数学规范     ┌─────────────────┐
│  FIPS 203 标准   │ ────────────→  │  Coq 形式化规范  │
│  (自然语言描述)   │                │  (数学定义)       │
└─────────────────┘                └────────┬────────┘
                                            │
                                            │ 证明等价
                                            ▼
┌─────────────────┐     提取/翻译     ┌─────────────────┐
│  C 实现代码      │ ────────────→  │  Coq 形式化代码  │
│  (mlkem.c)       │                │  (语义映射)       │
└─────────────────┘                └─────────────────┘

3.2 Coq 证明系统入门

Coq 是一个交互式定理证明器，支持构造性类型论。Apple 使用 Coq 来验证 ML-KEM 和 ML-DSA 的正确性。

基本语法示例：

(* 定义模运算 *)
Definition modn (n m : nat) : nat :=
  match n with
  | O => O
  | S n' => if n' <? m then S n' else modn (n' - m) m
  end.

(* 证明简单性质 *)
Lemma modn_small : forall n m, n < m -> modn n m = n.
Proof.
  intros n m H.
  induction n.
  - reflexivity.
  - simpl. rewrite Nat.ltb_lt in H. auto.
Qed.

ML-KEM 核心性质的 Coq 规范：

(* ML-KEM 正确性定理 *)
Theorem mlkem_correctness :
  forall (pk : public_key) (sk : secret_key) (m : plaintext),
    valid_keypair pk sk ->
    let (ct, K1) := encaps pk m in
    let K2 := decaps sk ct in
    K1 = K2.
Proof.
  (* 证明涉及数百步，这里省略细节 *)
  intros pk sk m Hvalid.
  unfold encaps, decaps.
  (* 关键步骤：证明多项式运算的正确性 *)
  apply poly_correctness.
  (* 应用 NTT 正确性定理 *)
  apply ntt_inverse.
  (* 证明误差分布的正确性 *)
  apply cbd_distribution.
Qed.

3.3 Apple 的形式化验证方法论

Apple 的验证框架包含三个层次：

Layer 1：算法规范层

(* FIPS 203 规范的形式化定义 *)
Module MLKEM_Spec.
  (* 参数定义 *)
  Definition n : nat := 256.  (* 多项式次数 *)
  Definition q : nat := 3329. (* 模数 *)
  Definition k : nat := 3.    (* ML-KEM-768 *)
  
  (* 多项式类型 *)
  Definition Poly := Vector.t Z n.
  Definition PolyVec := Vector.t Poly k.
  
  (* 规范化的封装函数 *)
  Definition encaps_spec (pk : public_key) : ciphertext * shared_key :=
    (* 数学定义 *)
    ...
End MLKEM_Spec.

Layer 2：实现语义层

(* C 代码的语义映射 *)
Module MLKEM_Impl.
  (* 内存模型 *)
  Definition memory := Map.t addr value.
  
  (* 程序状态 *)
  Definition state := (memory * regs).
  
  (* 提取函数：C 代码 → Coq 表达式 *)
  Definition extract_encaps (prog : C.program) : Coq.Expr :=
    (* 使用 CompCert 的提取机制 *)
    ...
End MLKEM_Impl.

Layer 3：等价性证明

(* 核心定理：实现与规范等价 *)
Theorem impl_eq_spec :
  forall (pk : public_key) (sk : secret_key),
    valid_keypair pk sk ->
    MLKEM_Impl.extract_encaps impl_code pk = MLKEM_Spec.encaps_spec pk.
Proof.
  (* 使用符号执行 + 定理证明 *)
  ...
Qed.

3.4 形式化验证的实际价值

Apple 的形式化验证发现并修复了多个潜在问题：

案例1：NTT 边界条件

原始实现中，NTT 在特定边界条件下的行为未明确定义：

// 有问题的代码
int32_t reduce(int32_t a) {
    int32_t t;
    t = a >> 15;  // 问题：右移的舍入方向未定义
    t = a - t * Q;
    return t;
}

形式化验证发现，在补码表示下，负数的右移行为是实现定义的。修复后：

// 修复后的代码
int32_t reduce(int32_t a) {
    int32_t t;
    t = (a + (1 << 14)) >> 15;  // 明确的舍入
    t = a - t * Q;
    return t;
}

案例2：常量时间要求

侧信道分析发现，某个条件分支可能泄露信息：

// 有问题的代码
if (memcmp(expected, computed, 32) == 0) {
    return 0;  // 成功路径
} else {
    return -1;  // 失败路径
}

修复为常量时间实现：

// 常量时间比较
uint8_t diff = 0;
for (size_t i = 0; i < 32; i++) {
    diff |= expected[i] ^ computed[i];
}
return (diff == 0) ? 0 : -1;  // 但这个分支仍然不是常量时间！

真正常量时间的实现：

// 真正的常量时间
uint8_t diff = 0;
for (size_t i = 0; i < 32; i++) {
    diff |= expected[i] ^ computed[i];
}
return -((diff == 0) ? 0 : 1);  // 使用算术而非分支

四、生产环境落地指南

4.1 从传统密码迁移到后量子密码

迁移策略分为三个阶段：

Phase 1：混合模式（当前推荐）

同时使用传统算法和后量子算法，提供「过渡期安全」：

传统密钥交换（ECDH） ←→ 后量子密钥交换（ML-KEM）
         ↓                        ↓
    shared_key_1              shared_key_2
         └───────────┬───────────┘
                     ↓
              KDF(shared_key_1 || shared_key_2)
                     ↓
                 final_key

代码示例（混合密钥交换）：

import CryptoKit
import CoreCrypto

func hybridKeyExchange(peerPublicKey: P256.KeyAgreement.PublicKey,
                       peerMLKEMKey: MLKEM.PublicKey) throws -> SymmetricKey {
    // 传统 ECDH
    let ecdhPrivateKey = P256.KeyAgreement.PrivateKey()
    let ecdhSharedSecret = try ecdhPrivateKey.sharedSecretFromKeyAgreement(
        with: peerPublicKey
    )
    
    // 后量子 ML-KEM
    let (mlkemCipherText, mlkemSharedSecret) = MLKEM.encapsulate(
        publicKey: peerMLKEMKey
    )
    
    // 混合密钥派生
    let combinedSecret = ecdhSharedSecret.rawRepresentation + mlkemSharedSecret
    let finalKey = SHA256.hash(data: combinedSecret)
    
    return SymmetricKey(data: finalKey)
}

Phase 2：后量子优先

当量子威胁更加明确时，切换到后量子优先模式：

// 后量子优先，传统作为后备
let key = try mlkemSharedSecret ?? ecdhSharedSecret

Phase 3：纯后量子

当量子计算机成为现实威胁时，完全迁移到后量子算法。

4.2 iMessage PQ3 协议深度解析

苹果在 iMessage 中实现了 PQ3 协议，这是大规模部署后量子密码学的典型案例。

PQ3 设计目标：

密钥交换时即提供后量子保护：初始握手使用 ML-KEM
定期密钥轮换：每次消息都可能触发密钥刷新
前向保密：历史消息不会因密钥泄露而被解密

PQ3 协议流程（简化）：

Alice                                  Bob
  |                                      |
  |------ InitMessage ------------------>|
  |  (ECDH_pk_A, MLKEM_pk_A, signature)  |
  |                                      |
  |<----- InitResponse ------------------|
  |  (ECDH_pk_B, MLKEM_ct_B, signature)  |
  |                                      |
  |                                      |
  | [共享密钥派生]                         |
  | K = KDF(ECDH_shared || MLKEM_shared)  |
  |                                      |
  |<===== 双向加密通信 ==================>|
  |                                      |
  |------ RekeyMessage (定期) ----------->|
  |  (new MLKEM_pk, new MLKEM_ct)         |
  |                                      |
  | [密钥刷新]                             |
  | K' = KDF(K || new_MLKEM_shared)       |

密钥轮换频率：

苹果采用动态轮换策略：

每 50 条消息：检查是否触发轮换
每 24 小时：强制轮换
检测到异常：立即轮换

4.3 性能优化实战

在实际部署中，性能优化至关重要。

优化1：预计算

// 密钥生成时预计算 NTT 域的基
typedef struct {
    mlkem_polyvec public_key;
    mlkem_polyvec secret_key;
    // 预计算的 NTT 域表示
    mlkem_polyvec public_key_ntt;
} mlkem_keypair_optimized;

int mlkem_keygen_optimized(mlkem_keypair_optimized *kp) {
    // 标准密钥生成
    mlkem_keygen(&kp->public_key, &kp->secret_key);
    
    // 预计算 NTT 域表示
    mlkem_polyvec_ntt(&kp->public_key_ntt, &kp->public_key);
    
    return 0;
}

优化2：批量操作

// 批量封装（适用于服务器场景）
int mlkem_encaps_batch(const uint8_t *pk, 
                       uint8_t *ct_array, 
                       uint8_t *ss_array, 
                       size_t count) {
    // 使用 SIMD 指令并行处理
    #pragma omp parallel for
    for (size_t i = 0; i < count; i++) {
        mlkem_encaps(pk, ct_array + i * KYBER_CIPHERTEXTBYTES, 
                     ss_array + i * 32);
    }
    return 0;
}

优化3：内存池

// 避免频繁内存分配
typedef struct {
    uint8_t buffer[64 * 1024];  // 预分配大块内存
    size_t offset;
} mlkem_memory_pool;

void *pool_alloc(mlkem_memory_pool *pool, size_t size) {
    void *ptr = pool->buffer + pool->offset;
    pool->offset += size;
    // 对齐
    pool->offset = (pool->offset + 63) & ~63;
    return ptr;
}

4.4 安全审计清单

部署后量子密码学时，务必检查：

清单1：算法选择

使用 NIST 标准化的 ML-KEM / ML-DSA
选择合适的安全等级（ML-KEM-768 推荐用于长期安全）
混合模式作为过渡方案

清单2：实现安全

使用常量时间实现
检查边界条件处理
验证随机数生成器质量
检查内存清理（密钥使用后清零）

// 密钥清理
void secure_zero(void *ptr, size_t len) {
    volatile uint8_t *p = ptr;
    while (len--) {
        *p++ = 0;
    }
}

清单3：协议设计

密钥轮换机制
前向保密保证
降级攻击防护
重放攻击防护

清单4：测试覆盖

NIST 官方测试向量全部通过
边界条件测试
模糊测试
性能基准测试

五、未来展望：后量子密码学的演进

5.1 标准化进程

NIST 后量子密码学标准化的第二、三轮正在进行：

SPHINCS+：无状态哈希签名（已标准化为 FIPS 205）
Falcon：格基签名（即将标准化）
NTRU：备用格基方案

Apple 的 CoreCrypto 开源为业界提供了宝贵的参考实现，预计更多厂商将跟进。

5.2 硬件加速

后量子密码学的硬件支持正在加速：

Intel PQC 指令集（预计 2027 年）：

VPMADD52：52-bit 模乘加速
VPCLMULQDQ：进位乘法加速

ARM PQC 扩展：

向量扩展支持多项式运算
专用模约简指令

5.3 形式化验证的普及

Apple 的开源证明了形式化验证在密码学实现中的可行性。预计：

更多开源密码库将采用形式化验证
验证工具链将更加自动化
新的验证方法（如类型系统保证常量时间）将出现

六、总结：安全是一场永不停歇的军备竞赛

Apple CoreCrypto 的开源具有里程碑意义：

透明度：业界首次完整公开后量子密码学实现的形式化验证
方法论：展示了如何用数学证明保障密码学实现的正确性
推动力：加速了后量子密码学在业界的采用

核心启示：

密码学的安全性不只依赖于数学难题的困难性，更依赖于实现的正确性。形式化验证是连接理论与实践的桥梁。

对于开发者而言，现在应该：

了解后量子密码学的基本原理
评估系统中的密钥安全需求
制定渐进式迁移计划
关注标准演进和工具链成熟度

量子威胁不是「是否会来」的问题，而是「何时来」的问题。提前准备，才能在未来立于不败之地。

参考资料

Apple Security Engineering & Architecture. (2026). CoreCrypto Post-Quantum Cryptography Implementation. GitHub.
NIST. (2024). FIPS 203: Module-Lattice-Based Key-Encapsulation Mechanism Standard.
NIST. (2024). FIPS 204: Module-Lattice-Based Digital Signature Standard.
Peikert, C. (2016). A Decade of Lattice Cryptography. Foundations and Trends in Theoretical Computer Science.
Apple Platform Security. (2026). iMessage PQ3 Protocol Overview.

关键词：Apple CoreCrypto, 后量子密码学, ML-KEM, ML-DSA, 形式化验证, 格密码学, iMessage PQ3, FIPS 203, FIPS 204, 量子计算

复制全文生成海报密码学安全 Apple 后量子形式化验证