Files
ssw-mpc/docs/N_PARTY.md
T
admin 54781b3f83
ci / gate (push) Waiting to run
refactor: 项目改名 ssw-mpc,crate 统一到 mpc-* 前缀
- 项目与文档标题:nax-rs → ssw-mpc(尚数网-多方安全计算),二进制 nax → mpc
- 18 个 crate 及目录 nax-* → mpc-*,Rust 引用 nax_* → mpc_*
- 环境变量、C 符号、构建/部署脚本:NAX_* → MPC_*、libnax_ray.so → libmpc_ray.so
- 保留协议域分隔常量与 refs/nax 参考实现路径,维持 golden 向量与历史数据兼容
- 新增 [profile.dev] incremental=false
2026-11-05 15:06:12 +08:00

263 lines
13 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# n 方(n > 2):哪些真的支持、哪些还不支持
> 一句话:**计算路径、PSI、纵向 LR、TEE 信任模型都是真 n 方的;SQL JOIN 仍是两方。**
> 这份文档的唯一目的是让这句话可核对 —— 每条"支持"都指得到测试,
> 每条"不支持"都写清是**协议限制**还是**没做**。
mpc 是 **N**-arty Arithmetic eXecution。两方是 n=2 的特例,不是框架的形状。
把两方当默认会带来一种很隐蔽的退化:代码在 n=2 时看着全对,
到 n=3 时不是崩,而是**算出一个错但合理的数**。
---
## 能力矩阵
| 模块 / 能力 | n > 2 | 证据 | 说明 |
|---|---|---|---|
| `mpc-core` 分片 / Beaver / 矩阵三元组 / 截断对 / edaBit | ✅ | `share::tests::split_reconstruct_roundtrip`(n=3)、`mul_triple_consistent`、`edabit_*` | 全部参数化 `n`,输出布局 `shares[party*len + i]` |
| `mpc-core` 安全比较 / 位代数 | ✅ | `compare::tests::*` | 逐位算子,本身不含 party 概念 |
| `mpc-vault` `open` / `mul` / `truncate` / `matmul_trunc` | ✅ | `open_three_party_sums_all`、`beaver_mul_three_party`、`truncate_three_party_puts_public_cs_once`、`mul_trunc_three_party_fixed_point`、`matmul_trunc_three_party` | 见下方"三处最容易错的地方" |
| `mpc-vault` 安全比较(`bit_lt` / `msb_raw` / 位代数) | ✅ | `bit_lt_three_party` | 走 edaBit + 多次 Beaver 乘 |
| `mpc-node` 网状连接 + 会话 | ✅ | `three_party_session_over_mesh`、`three_party_session_over_mesh_with_psk` | **真 TCP**,三方全网状,含 PSK 加密链路 |
| `mpc-psi` 隐私求交(环协议) | ✅ | `psi_three_party_over_mesh`、`psi_three_party_no_common_element`、`n_way_intersection_is_not_pairwise` | 真 TCP 三方;n=2 退化为原两轮交换,开销不变 |
| `mpc-sql` 竖向列交换 | ✅ | `exchange_split_columns_three_party` | 三方各持一列,按 party 下标拼回全局列序 |
| `mpc-he` HE-OLE 物料 | ✅ | `he_mul_triple_three_parties` | 每对做两次 OLE,无第三方 |
| `mpc-fl` 加权聚合 | ✅ | — | 客户端数是 `delta_shares.len()`,与参与方数无关 |
| `mpc-node` 纵向 LR(`run_lr_vertical_session`) | ✅ | `vertical_lr_three_party_matches_plaintext`、`three_party_column_order_differs_from_party_order` | n 方纵向切分 = 一张**列块清单**(见下方"列块");分片广播 n−1 份、按各块 offset 累加 |
| `mpc-cli` `lr-vertical` | ✅ | 三进程真 TCP 手动验证(三方与两方权重逐位相同) | 密态通道走 `--listen`/`--peers` 的端口 +1,不用再给一组地址 |
| `mpc-tee` `TrustPlan`(L0–L3) | ✅ | `second_tee_party_does_not_upgrade_grade`、`plan_is_order_independent`、`all_tee_but_one_unattested_is_l3` | 从"成对枚举"改成 `for_parties(&[PartyTee], TrustPolicy)`;CLI `mpc trust` 可查 |
| `mpc-sql` SQL JOIN | ❌ **协议限制** | `sql_join::run` 显式拒绝 n≠2 | JOIN 的语义是"两表按键拼列",n 方需要先定义"n 表连接"的 schema 与空位规则;不是被 PSI 卡住 |
---
## 三处最容易错的地方
n 方出错的地方**不在通信**,而在"公开值出现了几次"。同一份代码在 n=2 时
写错成 `2·x`,在 n=3 时错成 `3·x` —— 数值离谱但不报错,看着像精度问题。
1. **截断的 `cs`**:`c = x + r` 打开后,`c >> fxp` 是公开值,只能落在一方身上
(`Vault::truncate` 里 `if self.my_idx == 0`)。每方都减一次 → `n·cs − rt`。
2. **矩阵乘的 `d·e`**:同一个道理,只有 0 号补。
3. **常数项的 1**:`bit_not`、`bit_one` 也只在 0 号带 1。
这三处都有测试钉着,而且是**变异验证过的**:把 `if self.my_idx == 0` 改成
`if true`,`truncate_three_party_puts_public_cs_once` 立刻失败
(实测得到 `18446698035212651052` 而不是 `1572864`)。测试会不会失败,
和测试会不会通过同样重要。
### 第四处:列块的落点(n 方才现形)
纵向 LR 里每方只该往自己的列块写、只该往**对端的列块**加。写错成
"按收到的顺序排"或"按 party 下标落列",在两方时**永远正确**
(`j` 和 `offset` 恰好同值),三方且列序 ≠ party 序时才分叉 ——
值可能全对、列全串。
`three_party_column_order_differs_from_party_order` 专门构造这个场景
(party 序 alice,bob,carol 的 offset 是 2,1,0)。变异验证:把
`pb.offset` 换成 `j`,这条测试立刻失败,而另两条三方 LR 测试**照样通过**
—— 说明它测的确实是别的东西。
另外两处只在 n 方现形的问题:
- **列块顺序**:收到分片按到达顺序排,各方速度不同时偶发错位 —— 值全对、
语义全错。所以 `exchange_split_columns_multi` 一律按 party 下标收。
- **环上死锁**:n 方"发一个收一个"会让每方都在等下一方。`Vault::open` 与
列交换是**先全发、再全收**;PSI 因为集合可能很大,改用**分块流水**
(发一块收一块),道理相同但把在途数据压到恒定 32 KB。
---
## n 方 PSI 怎么做
两轮 DH-PSI 天然是两方的(每轮"对端"只有一个)。n 方求交不是把它包进
`for` 循环 —— 两两求交 ≠ n 方求交,反例 A={1,2} B={2,3} C={3,1}:
两两交集都非空,三方交集是空集。拿两两结果拼,会把三个元素全判成命中
(`n_way_intersection_is_not_pairwise` 钉的就是这条)。
`run_psi_session` 用的是**环协议**(Meadows / Huberman–Franklin–Hogg):
```text
阶段 0 方 i 盲化自己的集合:S_i^{k_i} = shuffle(k_i · H(ID))
阶段 A 沿环走 n-1 跳,每跳被当前持有者用自己密钥再幂一次
结束时 S_j^{K} 停在方 j-1 手里(K = k_1·k_2·…·k_n)
阶段 B 每方把自己手上那份完整集合广播给其余 n-1 方
至此每方持有全部 n 个 S_j^{K},本地求交
```
传输是按集合算的,不是按点算(每方每跳只传手上**一个**集合):
| | 两轮 DH-PSI(n=2) | 环协议(n 方) |
|---|---|---|
| 通信轮次 | 2 | n(n−1 跳环 + 1 轮广播) |
| 每方发出 | 2\|X\| 点 | 2(n−1)\|X\| 点 |
| 每方模幂 | 2\|X\| 次 | 2(n−1)\|X\| 次(n=2 时同为 2\|X\|) |
| 新增帧类型 | — | 无(复用 `Op::PsiPoints`) |
| 安全假设 | DDH + 半诚实 | 同左 |
**n=2 时开销与旧实现逐项相同**,所以没有保留单独的"两方快路径"——
一份实现、一份测试。
### 安全边界(说清楚,不美化)
**已经做的三道硬化**(`mpc-psi::strict`):
| 防护 | 挡什么 | 证据 |
|---|---|---|
| 低阶点拒绝 | 喂 8-torsion 点(`u=0/1/p-1` 与两个阶 8 点)。这类点会让 `k·P` 的取值空间退化,逐点重复可拼出密钥低位 | `psi_rejects_injected_low_order_point`(真 MeshPipe 三方,一方注入 `u=1`) |
| 点集自检 | 本方集合有重复 ID、对端塞重复点 | `strict::rejects_duplicates_and_reports_both_positions` |
| 会话绑定 domain | 同一 ID 在不同会话映射到不同点,**离线预计算表**不能跨会话复用 | `strict::same_id_yields_different_points_across_sessions` |
低阶点这条做过变异验证:去掉接收侧的 `check_points`,攻击测试立刻失败,
而且是**三方都返回空交集、谁都不报错**的形态 —— 正是攻击成功的表象。
**仍然挡不住的(这才是完整的话)**:
- **替换式探针**。恶意方把集合里第 i 个元素换成想查的 `x'`,仍能学到
"`x'` 在不在对方集合里"。代价是它失去了原来那个元素的状态,但那是
可接受的代价。要闭合它,必须让恶意方**证明**提交的每个点确实是它承诺
集合中元素的像(输入绑定 + 零知识证明),也就是 OPRF-PSI 的范畴
(KKRT / ecOPRF)。这不是"加几个校验"能到的。
- **多轮累积**。恶意方可以在很多场会话里每场换一个探针,逐步把对方集合
映射出来。任何不绑定**长期身份**与**集合承诺**的 PSI 都有这个问题。
- 环上中间方看到的是"别人集合乘了部分密钥"的点,反推 ID 等价于解 X25519
离散对数,与两方版本同级。
- 每方种子**必须不同**。同种子 = 同私钥,交集仍然算得对,但隐私性直接失效
—— 这是最隐蔽的一种失败,CLI 从 `(seed, site)` 派生正是为此。
- `session` **必须全体一致**,而 `seed` 必须全体不同。这两个要求相反,
用错任一个的结果都是"不报错、交集为空"。
### 规模:必须分块,否则必死锁
一开始是"整份集合发一帧"。10 万条(3.2 MB/方)在 macOS 上**必然卡死**:
发送缓冲默认只有 ~128 KB,写满后每方都在等对方读 —— 实测 256 秒后
以 `Broken pipe` 失败。5000 条能过,只是因为它装得下缓冲。
**这是最容易被小规模测试骗过去的那类缺陷**(规模相关,不是逻辑错)。
现在 `pipeline_points` 按 1024 点(32 KB)分块,发一块收一块,
在途数据与总规模无关。实测(`--release`,i5-5250U):
| 规模 | 方数 | 耗时 |
|---|---|---|
| 10 万 | 2 | 34 s |
| 10 万 | 3 | 90 s |
复现:
```bash
cargo test --release -p mpc-node --lib -- --ignored --nocapture psi_large
```
---
## 列块:n 方纵向切分怎么定义
两方纵向 LR 的"切分"是隐含的:一方持左半列、一方持右半列,`col_offset`
只能是 `0` 或 `d_peer`。n 方的切分必须**显式写下来**,就是一张列块清单:
```text
alice:0:1, bob:1:1, carol:2:1 # site:offset:len,铺满 [0, 3)
```
四条约束,任何一条不满足都在**碰网络之前**拒绝(`validate_col_blocks`):
1. 条数 = 参与方数;
2. **`blocks[i]` 必须对应 `sites[i]`** —— 分片按 party 下标收发,只校验
"集合相同"是不够的(按 offset 排过序的清单会让 `blocks[1]` 指向第三方);
3. 排序后首尾相接,无空洞无重叠;
4. 铺满 `0..d_total`。
第 2 条是这轮真正修掉的一个隐患:我最初只写了"集合相等",而
`three_party_column_order_differs_from_party_order` 这条测试构造的正是
"清单顺序 ≠ party 顺序",一验就露。
### 分片怎么落列
```text
本方:x_sh[i*d_total + my_offset + k] = my_shard[i*d_own + k] ← 直接写
对端 j:x_sh[i*d_total + blocks[j].offset + k] += peer_shard[...] ← 累加
```
用 `blocks[j].offset` 而不是 `j`。两方时两者永远同值,三方且列序被打乱时
才分叉 —— 这就是为什么这条必须单独有一条测试。
## TrustPlan 在 n 方是什么
成对枚举(`TeeAssisted { tee_side }` / `MutualAttested`)在 n 方直接失效:
"哪一方有 TEE"变成了"哪几方有"。现在它是一个**计算函数**:
```rust
TrustPlan::for_parties(&[PartyTee], TrustPolicy) -> Result<TrustPlan, TeeError>
```
判据:
| 条件 | 方案 | 含义 |
|---|---|---|
| 全体无 TEE | `MpcOnly` (L0) | 只有 MPC 数学 |
| 部分方有 TEE | `TeeAssisted { tee_sides }` (L1) | MPC 仍是主力,TEE 只保护那几方的输入 |
| 全体有 TEE + 全体 attest + TCB 达标 + 客户明示允许合并 | `MutualAttested` (L2) | 可明文直算 |
| 其余(全有 TEE 但不满足上一条) | `TeePerParty` (L3) | MPC 保底,TEE 保输入 |
**n 方比两方严**:L2 要求**每一方**都 attest 通过,而不是"有人在用 TEE"。
原因是合并明文后,那份明文对**执行计算的那一方**完全可见 —— 只要有一个
不受信方,全体数据就都在它眼前。两方时"一方有 TEE = 双方都被覆盖"这个
直觉在 n 方是错的(`second_tee_party_does_not_upgrade_grade` 钉住这条)。
MPC 侧假设没跟着变:分片重建是 `n`-out-of-`n`,不需要诚实多数,但**不允许
任何一方掉线**。TEE 帮不上这一条。
查当前配置:
```bash
mpc trust --parties "alice=sev-snp:5+attested,bob=tdx:4+attested,carol=none" --allow-plaintext-merge
# → L1,untrusted_sides = carol,needs_mpc = true
```
---
## 自己验
```bash
# n 方算子(vault 层,内存全互联)
cargo test -p mpc-vault --lib three_party
# n 方真 TCP(起三个实际 socket)
cargo test -p mpc-node three_party
# n 方 PSI(真 TCP 三方 + 无公共元素的反例)
cargo test -p mpc-node --lib psi_three_party
# n 方竖向列交换
cargo test -p mpc-sql --features secure exchange_split_columns_three_party
# n 方纵向 LR(三方各持一列,对拍明文 LR)
cargo test -p mpc-node --test lr_vertical_psi three_party
# PSI 抗恶意硬化(低阶点注入必须被拒)
cargo test -p mpc-node --lib psi_rejects_injected_low_order_point
cargo test -p mpc-psi -- strict
# 可信度方案矩阵
cargo test -p mpc-tee --lib trust
```
命令行三进程跑真 PSI:
```bash
S=alice,bob,carol
P="alice=127.0.0.1:9440,bob=127.0.0.1:9441,carol=127.0.0.1:9442"
mpc psi --site alice --sites $S --listen 127.0.0.1:9440 --peers $P \
--ids 1,2,3,4,5 --seed 1111... &
mpc psi --site bob --sites $S --listen 127.0.0.1:9441 --peers $P \
--ids 3,4,5,6,7 --seed 2222... &
mpc psi --site carol --sites $S --listen 127.0.0.1:9442 --peers $P \
--ids 4,5,6,7,8 --seed 3333... &
# 三方都应输出 4,5
```
内存通道用 `mpc_vault::MeshPipe::mesh(n)`:每对 (i,j) 一条独立管道,
`recv_from(party)` 严格按来源取帧 —— 和 `TcpMesh` 语义一致。
用 `Pipe::pair()` 串成 n 方是**错的**:它忽略 party 参数,
会把"发给 2 号"静默送给 1 号,那正是要测的东西。