Files
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

494 lines
18 KiB
Rust
Raw Permalink 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.
//! JOIN + PSI 接进密态 SQL:2 方 in-process 端到端,逐值对拍明文引擎。
//!
//! ```text
//! PSI(mpc-node::run_psi_session)
//! → 按共享规范键排序、裁剪(发生在这里,调用方)
//! → 切分片 + 交换(mpc-sql::secure::exchange_split_columns)
//! → 密态掩码 WHERE / 聚合 / GROUP BY(mpc-sql::secure)
//! → reveal,与明文 Engine 的等价 JOIN 查询逐值比对
//! ```
//!
//! # 分层:为什么 PSI 和对齐不在 `mpc-sql` 里
//!
//! `mpc-sql::secure` 只吃「已对齐的分片」,库依赖图里没有 `mpc-node`/`mpc-psi`。
//! PSI 是**调用方**的编排责任(生产环境是 `mpc-cli`,这里是测试),
//! 否则 SQL 层会被钉死在「先做 PSI 才能查」这一种拓扑上。本文件的
//! `mpc-node`/`mpc-psi` 是 **dev-dependency**,不进库的依赖闭包。
//!
//! # 为什么必须排序才能对齐
//!
//! PSI 只回答「本方哪几条记录在交集里」,返回的是**本地行序**升序的下标;
//! 两方拿到的下标序列互不相同、也不含共享顺序。而纵向聚合要求
//! 「两方的第 i 行是同一个人」,所以两边必须按同一个全序重排 ——
//! 这里用 join 键的字节序(十进制编码后的字典序)。
//!
//! 副作用(已知且接受):排序暴露了本方键相对对端键的秩,与 PSI 本身
//! 泄露交集是同一量级的元信息;不排序则结果直接错。
//!
//! 测试数据故意让两方本地顺序**相反**:不排序就会算错(见
//! [`alignment_orders_both_sides_identically`] 与 WHERE 用例的期望值)。
#![cfg(feature = "secure")]
use std::thread;
use mpc_node::{run_psi_session, PsiConfig};
use mpc_psi::id_from_u64;
use mpc_sql::engine::{ColData, Engine, ResultTable, Table};
use mpc_sql::secure::{
exchange_split_columns, secure_aggregate_all, secure_group_by, secure_where_aggregate_pred,
Agg, CmpOp, Pred,
};
use mpc_vault::{Pipe, Transport, Vault};
const FXP: u32 = 18;
const SITES: [&str; 2] = ["alice", "bob"];
// ---------------------------------------------------------------------------
// 数据:alice 持 (id, balance),bob 持 (uid, spend, region)
// ---------------------------------------------------------------------------
/// 一方的表。`ids` 是 join 键;`cols` 是数值列(f64,密态侧按 fxp 编码)。
#[derive(Clone)]
struct Party {
site: &'static str,
/// PSI 会话种子。两方**故意不同** —— 同种子等于双方私钥相同,
/// ECDH 就退化成一个共享标量,测不出真实协议的交换律。
psi_seed: [u8; 32],
ids: Vec<u64>,
cols: Vec<Vec<f64>>,
}
impl Party {
/// PSI 用的键字节(与 `mpc_psi::id_from_u64` 的十进制编码一致)。
fn keys(&self) -> Vec<Vec<u8>> {
self.ids.iter().map(|v| id_from_u64(*v)).collect()
}
/// 按给定行序重排列。
fn take_rows(&self, order: &[usize]) -> Vec<Vec<f64>> {
self.cols
.iter()
.map(|c| order.iter().map(|&i| c[i]).collect())
.collect()
}
}
/// 两方本地顺序**互不相同**,交集 = {2, 3, 4}(3 条)。
fn sample() -> (Party, Party) {
let alice = Party {
site: "alice",
psi_seed: [0x11; 32],
ids: vec![7, 2, 4, 1, 8, 3],
cols: vec![vec![700.0, 200.0, 400.0, 100.0, 800.0, 300.0]], // balance
};
let bob = Party {
site: "bob",
psi_seed: [0x22; 32],
ids: vec![4, 9, 2, 3, 5],
cols: vec![
vec![40.0, 90.0, 20.0, 30.0, 50.0], // spend
vec![1.0, 0.0, 0.0, 0.0, 1.0], // region(公开组码)
],
};
(alice, bob)
}
/// 对齐后(键 2,3,4)两方的行:
///
/// | key | alice.balance | bob.spend | bob.region |
/// |-----|---------------|-----------|------------|
/// | 2 | 200 | 20 | 0 |
/// | 3 | 300 | 30 | 0 |
/// | 4 | 400 | 40 | 1 |
///
/// 若 alice 少排了序,行序会变成 (2, 4, 3) → balance 列 [200, 400, 300]
/// 对上 spend [20, 30, 40],`balance >= 250 AND spend < 40` 会算出
/// 400 而不是 300 —— WHERE 用例的期望值就是用来抓这个的。
fn plaintext(a: &Party, b: &Party) -> Engine {
let bank = Table::new("bank", "alice")
.with_col(
"id",
ColData::Num(a.ids.iter().map(|&v| v as f64).collect()),
)
.with_col("balance", ColData::Num(a.cols[0].clone()))
.with_key("id");
let shop = Table::new("shop", "bob")
.with_col(
"uid",
ColData::Num(b.ids.iter().map(|&v| v as f64).collect()),
)
.with_col("spend", ColData::Num(b.cols[0].clone()))
.with_col("region", ColData::Num(b.cols[1].clone()))
// GROUP BY 要求取值域公开:region 是公开组码 0/1
.with_public("region")
.with_key("uid");
let mut e = Engine::new(0);
e.register(bank);
e.register(shop);
e
}
fn num(rt: &ResultTable, row: usize, col: &str) -> f64 {
rt.get(row, col).and_then(|v| v.as_num()).expect("数值")
}
// ---------------------------------------------------------------------------
// 行对齐:调用方的责任
// ---------------------------------------------------------------------------
/// 把「本方落在交集里的行」按**共享规范键**排序,返回按对齐行序排列的行下标。
///
/// 排序键是键的字节序 —— 任何两方一致的**全序**都行,重要的是不能依赖
/// 本地行序(PSI 给的正是本地行序)。
fn align_by_key(keys: &[Vec<u8>], hits: &[usize]) -> Result<Vec<usize>, String> {
if hits.is_empty() {
// 零命中不是「结果为空」而是「这次 join 没有公共样本」——
// 继续往下跑会让两方都拿着空列去 open,必须在这里明确失败。
return Err("交集为空:两方没有可对齐的行".into());
}
if let Some(&bad) = hits.iter().find(|&&i| i >= keys.len()) {
return Err(format!("PSI 交集中出现越界下标 {bad}"));
}
let mut order = hits.to_vec();
order.sort_by(|&x, &y| keys[x].cmp(&keys[y]));
// 本方键必须唯一:重复键对应一对多 join,纵向对齐(一人一行)表达不了
if let Some(w) = order.windows(2).find(|w| keys[w[0]] == keys[w[1]]) {
return Err(format!(
"join 键在本方重复(第 {} 与第 {} 行),一对多 join 不支持",
w[0], w[1]
));
}
Ok(order)
}
// ---------------------------------------------------------------------------
// 密态侧:同一份「计划」在两边对称执行
// ---------------------------------------------------------------------------
/// 一条查询在密态侧的执行方式。列下标是**全局列序**(alice 的列在前)。
///
/// 两边必须执行完全相同的计划:MPC 的每一轮都是对称的,一侧多跑一次
/// `bit_lt` 就会和另一侧错开一帧,然后死锁。
#[derive(Clone)]
enum Plan {
/// 无 WHERE:`SELECT <aggs(col)> FROM <已对齐>`。
All { col: usize, aggs: Vec<Agg> },
/// `SELECT <aggs(col)> FROM <已对齐> WHERE <pred>`。
Where {
pred: Pred,
col: usize,
aggs: Vec<Agg>,
},
/// `SELECT g, <aggs(col)> ... GROUP BY g`,`g` 的取值域是公开码 `0..n`。
GroupBy {
col: usize,
gcol: usize,
n_groups: usize,
aggs: Vec<Agg>,
},
}
impl Plan {
fn run<T: Transport>(&self, vault: &mut Vault<T>, cols: &[Vec<u64>]) -> Result<Vec<f64>, String> {
let e = |err: mpc_vault::VaultError| err.to_string();
match self {
Self::All { col, aggs } => secure_aggregate_all(vault, &cols[*col], aggs).map_err(e),
Self::Where { pred, col, aggs } => {
secure_where_aggregate_pred(vault, cols, pred, *col, aggs).map_err(e)
}
Self::GroupBy {
col,
gcol,
n_groups,
aggs,
} => {
let rows = secure_group_by(vault, &cols[*col], &cols[*gcol], *n_groups, None, aggs, 0)
.map_err(e)?;
Ok(rows.into_iter().flatten().collect())
}
}
}
}
/// 一方的完整链路。返回 `(对齐后的键序列, 本方算出的聚合值)`。
///
/// 键序列回传给测试,用来交叉确认两方**确实对齐到了同一顺序**。
#[allow(clippy::too_many_arguments)]
fn party_run(
psi: Pipe,
vault_pipe: Pipe,
me: &Party,
col_off: usize,
peer_cols: usize,
peer_off: usize,
total_cols: usize,
plan: &Plan,
seed: [u8; 32],
) -> Result<(Vec<Vec<u8>>, Vec<f64>), String> {
let keys = me.keys();
// 1) PSI:本方交集下标,按本地行序升序
// 两方单连接,my_idx 只决定环上的前后继(n=2 时两者都是唯一对端)
let my_idx = SITES
.iter()
.position(|s| *s == me.site)
.ok_or_else(|| format!("{} 不在 SITES 里", me.site))?;
let cfg = PsiConfig {
site: me.site.to_string(),
sites: SITES.iter().map(|s| s.to_string()).collect(),
my_idx,
ids: keys.clone(),
seed: me.psi_seed,
// session 取共享主种子(两方一致),psi_seed 是每方不同的
session: mpc_psi::strict::session_id(&seed),
};
let hits = run_psi_session(psi, &cfg, false).map_err(|e| format!("PSI 失败: {e}"))?;
// 2) 按共享规范键排序 —— 两边得到同一个顺序
let order = align_by_key(&keys, &hits)?;
// 3) 只留交集行,并按对齐行序重排
let aligned = me.take_rows(&order);
// 4) 切分片 + 交换(先全发、再全收)
let mut vault = Vault::new(vault_pipe, me.site, &SITES, seed, FXP)
.map_err(|e| format!("Vault 初始化失败: {e}"))?;
let (mine, theirs) =
exchange_split_columns(&mut vault, &aligned, peer_cols).map_err(|e| format!("列交换失败: {e}"))?;
// 5) 拼成全局列序(公开 schema:alice 的列在前、bob 的在后)
let mut cols = vec![Vec::new(); total_cols];
for (k, c) in mine.into_iter().enumerate() {
cols[col_off + k] = c;
}
for (k, c) in theirs.into_iter().enumerate() {
cols[peer_off + k] = c;
}
// 6) 密态聚合(内部 reveal)
let vals = plan.run(&mut vault, &cols)?;
let aligned_keys = order.iter().map(|&i| keys[i].clone()).collect();
Ok((aligned_keys, vals))
}
/// 起两条独立管道跑完整两方会话,返回两方各自的 `(键序列, 结果)`。
///
/// PSI 与密态会话各用一对管道:两者协议无关,混用同一条管道会让帧串到
/// 对方的 `recv` 上(`Shares` 与 `PsiPoints` 的 op 不同,会直接报协议错)。
fn run_two_party(a: &Party, b: &Party, plan: Plan) -> ((Vec<Vec<u8>>, Vec<f64>), (Vec<Vec<u8>>, Vec<f64>)) {
let n_a = a.cols.len();
let n_b = b.cols.len();
let seed = [0x5Bu8; 32]; // 共享会话主种子:Beaver 物料由它派生,两边必须一致
let (psi_a, psi_b) = Pipe::pair();
let (va, vb) = Pipe::pair();
let (a, b, plan_b) = (a.clone(), b.clone(), plan.clone());
let ha = thread::spawn(move || {
party_run(psi_a, va, &a, 0, n_b, n_a, n_a + n_b, &plan, seed)
.unwrap_or_else(|e| panic!("alice 侧失败: {e}"))
});
let hb = thread::spawn(move || {
party_run(psi_b, vb, &b, n_a, n_a, 0, n_a + n_b, &plan_b, seed)
.unwrap_or_else(|e| panic!("bob 侧失败: {e}"))
});
(ha.join().expect("alice 线程"), hb.join().expect("bob 线程"))
}
// ---------------------------------------------------------------------------
// 用例
// ---------------------------------------------------------------------------
/// 前提自检:PSI 输出(本地行序)两边不同,排序后才一致。
///
/// 这条测试同时防止「数据改得太巧,排序没生效也能过」。
#[test]
fn alignment_orders_both_sides_identically() {
let (a, b) = sample();
let (ka, kb) = (a.keys(), b.keys());
// 明文求交,模拟 PSI 的输出形状(本方交集下标、本地行序升序)
let mut sorted_b = kb.clone();
sorted_b.sort();
let hits_a: Vec<usize> = (0..ka.len())
.filter(|&i| sorted_b.binary_search(&ka[i]).is_ok())
.collect();
let mut sorted_a = ka.clone();
sorted_a.sort();
let hits_b: Vec<usize> = (0..kb.len())
.filter(|&i| sorted_a.binary_search(&kb[i]).is_ok())
.collect();
assert_eq!(hits_a, vec![1, 2, 5], "alice 侧交集下标");
assert_eq!(hits_b, vec![0, 2, 3], "bob 侧交集下标");
// 未排序:两边的键序列不同 —— 直接拿去切分片就是行错位
let raw_a: Vec<&Vec<u8>> = hits_a.iter().map(|&i| &ka[i]).collect();
let raw_b: Vec<&Vec<u8>> = hits_b.iter().map(|&i| &kb[i]).collect();
assert_ne!(raw_a, raw_b, "测试数据必须让两方本地顺序不同");
// 排序后:两边键序列逐条相同
let oa = align_by_key(&ka, &hits_a).unwrap();
let ob = align_by_key(&kb, &hits_b).unwrap();
let sa: Vec<&Vec<u8>> = oa.iter().map(|&i| &ka[i]).collect();
let sb: Vec<&Vec<u8>> = ob.iter().map(|&i| &kb[i]).collect();
assert_eq!(sa, sb, "排序后两方键序列必须一致");
assert_eq!(
sa,
vec![b"2".to_vec(), b"3".to_vec(), b"4".to_vec()]
.iter()
.collect::<Vec<_>>(),
"规范序 = 键字节序"
);
}
/// 重复键(一对多 join)必须在切分片之前拦下,而不是静默按行号错拼。
#[test]
fn alignment_rejects_duplicate_keys() {
let keys = vec![b"1".to_vec(), b"2".to_vec(), b"2".to_vec()];
let err = align_by_key(&keys, &[0, 1, 2]).unwrap_err();
assert!(err.contains("重复"), "错误信息应指出键重复: {err}");
// 越界下标来自协议错乱,同样要拦
assert!(align_by_key(&keys, &[0, 3]).is_err());
}
/// join 后 COUNT / SUM(无 WHERE),对拍 `SELECT COUNT(*), SUM(...) FROM bank JOIN shop`。
#[test]
fn join_count_sum_matches_engine() {
let (a, b) = sample();
let e = plaintext(&a, &b);
let rt = e
.sql(
"SELECT COUNT(*) AS n, SUM(bank.balance) AS b, SUM(shop.spend) AS s \
FROM bank JOIN shop ON bank.id = shop.uid",
)
.unwrap();
assert_eq!(num(&rt, 0, "n"), 3.0);
assert_eq!(num(&rt, 0, "b"), 900.0);
assert_eq!(num(&rt, 0, "s"), 90.0);
// 一次会话只能对一列求聚合,所以按列各跑一遍(计划两边对称即可)
let (r, r2) = run_two_party(
&a,
&b,
Plan::All {
col: 0,
aggs: vec![Agg::Count, Agg::Sum],
},
);
assert_eq!(r.0, r2.0, "两方对齐后的键序列必须一致");
assert_eq!(r.0.len(), 3, "交集 3 条");
// 整数在 fxp=18 下可精确表示,求和也精确 —— 不设容差
assert_eq!(r.1[0], 3.0, "COUNT");
assert_eq!(r.1[1], 900.0, "SUM(balance)");
let (r, r2) = run_two_party(
&a,
&b,
Plan::All {
col: 1,
aggs: vec![Agg::Sum],
},
);
assert_eq!(r2.1, r.1, "本端与对端 reveal 出的结果必须相同");
assert_eq!(r.1[0], 90.0, "SUM(spend)");
}
/// join + WHERE(跨两方的复合谓词)—— 行没对齐就会算错的那条。
#[test]
fn join_where_matches_engine() {
let (a, b) = sample();
let e = plaintext(&a, &b);
let sql = "SELECT COUNT(*) AS n, SUM(bank.balance) AS b, SUM(shop.spend) AS s \
FROM bank JOIN shop ON bank.id = shop.uid \
WHERE bank.balance >= 250 AND shop.spend < 40";
let rt = e.sql(sql).unwrap();
// 命中只有键 3 那一行:(balance 300, spend 30)
assert_eq!(num(&rt, 0, "n"), 1.0);
assert_eq!(num(&rt, 0, "b"), 300.0);
assert_eq!(num(&rt, 0, "s"), 30.0);
// 谓词跨两方:col 0 = alice.balance,col 1 = bob.spend
let pred = Pred::And(
Box::new(Pred::Cmp {
col: 0,
op: CmpOp::Ge,
threshold: 250.0,
}),
Box::new(Pred::Cmp {
col: 1,
op: CmpOp::Lt,
threshold: 40.0,
}),
);
let (r, r2) = run_two_party(
&a,
&b,
Plan::Where {
pred: pred.clone(),
col: 0,
aggs: vec![Agg::Count, Agg::Sum],
},
);
assert_eq!(r.1[0], num(&rt, 0, "n"), "COUNT");
assert_eq!(r.1[1], num(&rt, 0, "b"), "SUM(balance)");
let (r, _) = run_two_party(
&a,
&b,
Plan::Where {
pred,
col: 1,
aggs: vec![Agg::Sum],
},
);
assert_eq!(r.1[0], num(&rt, 0, "s"), "SUM(spend)");
let _ = r2;
}
/// join + GROUP BY:按 bob 的公开地区码分组,对拍 `GROUP BY shop.region`。
#[test]
fn join_group_by_matches_engine() {
let (a, b) = sample();
let e = plaintext(&a, &b);
let rt = e
.sql(
"SELECT shop.region AS r, COUNT(*) AS n, SUM(shop.spend) AS s \
FROM bank JOIN shop ON bank.id = shop.uid GROUP BY shop.region",
)
.unwrap();
// 域顺序 [0, 1]:组0 = 键 2,3 → n=2, s=50;组1 = 键 4 → n=1, s=40
assert_eq!(rt.nrows(), 2);
assert_eq!(num(&rt, 0, "n"), 2.0);
assert_eq!(num(&rt, 0, "s"), 50.0);
assert_eq!(num(&rt, 1, "n"), 1.0);
assert_eq!(num(&rt, 1, "s"), 40.0);
let (r, r2) = run_two_party(
&a,
&b,
Plan::GroupBy {
col: 1,
gcol: 2,
n_groups: 2,
aggs: vec![Agg::Count, Agg::Sum],
},
);
assert_eq!(r.1, r2.1, "两方 GROUP BY 结果必须一致");
// 扁平成 [n0, s0, n1, s1]
assert_eq!(r.1[0], 2.0, "组0 COUNT");
assert_eq!(r.1[1], 50.0, "组0 SUM");
assert_eq!(r.1[2], 1.0, "组1 COUNT");
assert_eq!(r.1[3], 40.0, "组1 SUM");
}
/// 交集为空时:PSI 返回空下标 → 对齐阶段就该报错(而不是拿空列表去跑聚合)。
#[test]
fn disjoint_tables_fail_before_aggregation() {
let keys = vec![b"1".to_vec(), b"2".to_vec()];
assert!(align_by_key(&keys, &[]).is_err(), "空交集应显式失败");
}