//! 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, cols: Vec>, } impl Party { /// PSI 用的键字节(与 `mpc_psi::id_from_u64` 的十进制编码一致)。 fn keys(&self) -> Vec> { self.ids.iter().map(|v| id_from_u64(*v)).collect() } /// 按给定行序重排列。 fn take_rows(&self, order: &[usize]) -> Vec> { 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], hits: &[usize]) -> Result, 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 FROM <已对齐>`。 All { col: usize, aggs: Vec }, /// `SELECT FROM <已对齐> WHERE `。 Where { pred: Pred, col: usize, aggs: Vec, }, /// `SELECT g, ... GROUP BY g`,`g` 的取值域是公开码 `0..n`。 GroupBy { col: usize, gcol: usize, n_groups: usize, aggs: Vec, }, } impl Plan { fn run(&self, vault: &mut Vault, cols: &[Vec]) -> Result, 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), 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), (Vec>, Vec)) { 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 = (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 = (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> = hits_a.iter().map(|&i| &ka[i]).collect(); let raw_b: Vec<&Vec> = 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> = oa.iter().map(|&i| &ka[i]).collect(); let sb: Vec<&Vec> = 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::>(), "规范序 = 键字节序" ); } /// 重复键(一对多 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(), "空交集应显式失败"); }