//! `mpc sql-join`:**真两进程 TCP** 的 JOIN × PSI × 密态 SQL 演示。 //! //! 与 `mpc sql`(in-process `Pipe::pair`)的区别:这里走真实 TCP,两个终端各起一方, //! 流程是 PSI 求交 → 按键字节序排序对齐 → 列分片交换 → 密态聚合 → reveal。 //! //! 分层约定:PSI 与行对齐在**本模块**(调用方),`mpc-sql::secure` 只吃已对齐的分片。 //! 对齐助手是 [`mpc_psi::align_by_key`],不在 `mpc-sql` 里。 //! //! # 全局列序:`--schema` //! //! 竖向切分里两方各持**不同列**(alice 持 `balance`、bob 持 `spend,region`), //! 密态聚合前必须拼出一致的全局列序。本模块用**公开 schema**约定: //! //! ```text //! --schema balance,spend,region ← 两方必须完全一致 //! alice: --data balance=... ← 只给自己拥有的列 //! bob: --data spend=... --data region=... //! ``` //! //! 列交换后按 schema 下标落位,而不是简单 `mine + theirs` —— 后者两方拼出来 //! 的顺序不同(alice 得 `[b,s,r]`、bob 得 `[s,r,b]`),谓词下标会静默错位。 use mpc_node::{run_psi_session, PsiConfig, TcpTransport}; use mpc_sql::secure::{ exchange_split_columns, secure_aggregate_all, secure_where_aggregate_pred, Agg, CmpOp, Pred, }; use mpc_vault::Vault; /// 解析 `--data name=v1,v2,...` 为 `(列名, 列值)`。 pub fn parse_col(spec: &str) -> Result<(String, Vec), String> { let (name, rest) = spec .split_once('=') .ok_or_else(|| format!("--data 缺少 '=': {spec:?}"))?; let name = name.trim().to_string(); if name.is_empty() { return Err("--data 列名为空".into()); } let vals: Vec = rest .split(',') .map(|t| t.trim().parse::().map_err(|_| format!("--data {name:?} 里 {t:?} 不是浮点"))) .collect::>()?; if vals.is_empty() { return Err(format!("--data {name:?} 没有值")); } Ok((name, vals)) } /// 解析 `--schema col1,col2,...` 为全局列名数组。 pub fn parse_schema(spec: &str) -> Result, String> { let names: Vec = spec .split(',') .map(|s| s.trim().to_string()) .filter(|s| !s.is_empty()) .collect(); if names.len() < 2 { return Err(format!("--schema 至少要两列,得到 {names:?}")); } let mut sorted = names.clone(); sorted.sort(); sorted.dedup(); if sorted.len() != names.len() { return Err("--schema 有重复列名".into()); } Ok(names) } /// 解析 `--pred` 为 [`Pred`](下标相对 schema)。 /// /// - `col OP col` —— 列 vs 列(如 `balance > spend`) /// - `col OP 数字` —— 列 vs 公开常量(如 `balance >= 250`) fn parse_pred(text: &str, schema: &[String]) -> Result { let find = |s: &str| -> Result { schema .iter() .position(|n| n == s) .ok_or_else(|| format!("谓词里的列 {s:?} 不在 schema {schema:?} 里")) }; for (tok, op) in [ (">=", CmpOp::Ge), ("<=", CmpOp::Le), ("!=", CmpOp::Ne), (">", CmpOp::Gt), ("<", CmpOp::Lt), ("=", CmpOp::Eq), ] { if let Some((lhs, rhs)) = text.split_once(tok) { let l = lhs.trim(); let r = rhs.trim(); if l.is_empty() || r.is_empty() { return Err(format!("谓词两侧不能为空: {text:?}")); } let li = find(l)?; if let Some(ri) = schema.iter().position(|n| n == r) { return Ok(Pred::CmpCol { col: li, op, rhs_col: ri, }); } let th: f64 = r .parse() .map_err(|_| format!("谓词右值 {r:?} 既不是列名也不是数字"))?; return Ok(Pred::Cmp { col: li, op, threshold: th, }); } } Err(format!("谓词 {text:?} 里没找到比较运算符(>= <= != > < =)")) } /// 跑一方:TCP 连接 → PSI → 对齐 → 列交换 → 密态聚合。 /// /// 返回 `(对齐后的键序列, [COUNT, SUM, AVG, MIN, MAX])`。 /// /// # 两个种子,别搞混 /// /// - `psi_seed` —— **每方不同**。同种子 = 双方 ECDH 私钥相同,协议退化。 /// - `vault_seed` —— **两方必须一致**。Beaver 物料由它派生,不一致则所有 /// 乘法(含比较)结果都是垃圾值。 #[allow(clippy::too_many_arguments)] pub fn run( site: &str, sites: &[String], transport: &mut TcpTransport, ids: &[u64], cols: &[(String, Vec)], schema: &[String], agg_col: &str, pred_text: Option<&str>, psi_seed: [u8; 32], vault_seed: [u8; 32], fxp: u32, verbose: bool, ) -> Result<(Vec, Vec), String> { // ---- 入口校验(碰网络前)---- if sites.len() != 2 { return Err(format!("sql-join 目前只支持两方,得到 {} 方", sites.len())); } if ids.is_empty() { return Err("--ids 为空".into()); } if cols.is_empty() { return Err("至少要有一个 --data 列".into()); } let n = ids.len(); for (name, vals) in cols { if vals.len() != n { return Err(format!( "列 {name:?} 有 {} 行,与 --ids 的 {n} 行不一致", vals.len() )); } } // 本方列必须都在 schema 里,且不重复 for (name, _) in cols { if !schema.contains(name) { return Err(format!("列 {name:?} 不在 schema {schema:?} 里")); } } { let mut mine = cols.iter().map(|(n, _)| n.clone()).collect::>(); mine.sort(); mine.dedup(); if mine.len() != cols.len() { return Err("--data 里有重复列名".into()); } } let agg_idx = schema .iter() .position(|x| x == agg_col) .ok_or_else(|| format!("--agg-col {agg_col:?} 不在 schema {schema:?} 里"))?; // 本方列在 schema 里的下标(升序 = 本方 --data 顺序之外的安全排序) let mut my_slots: Vec = cols .iter() .map(|(name, _)| { schema .iter() .position(|s| s == name) .expect("上面已校验在 schema 里") }) .collect(); my_slots.sort_unstable(); // 对端列占剩下的 schema 槽位 let peer_slots: Vec = (0..schema.len()).filter(|i| !my_slots.contains(i)).collect(); let keys: Vec> = ids.iter().map(|&v| mpc_psi::id_from_u64(v)).collect(); // ---- 1) PSI:本方交集下标(本地行序升序)---- // JOIN 本身是两方协议,my_idx 只有 0/1;单连接 transport 忽略 party。 let my_idx = sites .iter() .position(|s| *s == site) .ok_or_else(|| format!("site {site} 不在 sites {sites:?} 里"))?; let psi_cfg = PsiConfig { site: site.to_string(), sites: sites.to_vec(), my_idx, ids: keys.clone(), seed: psi_seed, // session 取共享的 Vault 种子(两方一致);psi_seed 是每方不同的 session: mpc_psi::strict::session_id(&vault_seed), }; let hits = run_psi_session(&mut *transport, &psi_cfg, verbose).map_err(|e| e.to_string())?; if verbose { eprintln!(" PSI 交集 {} 条", hits.len()); } // ---- 2) 按共享规范键排序 —— 两方得到同一个顺序 ---- let order = mpc_psi::align_by_key(&keys, &hits)?; let m = order.len(); if verbose { eprintln!(" 对齐后 {m} 行"); } // ---- 3) 只留交集行,按对齐行序重排本方各列(按 my_slots 升序)---- // `exchange_split_columns` 收发按 `--data` 给的列序,所以先按 my_slots 排好 let mut ordered_cols: Vec<&(String, Vec)> = cols.iter().collect(); ordered_cols.sort_by_key(|(name, _)| schema.iter().position(|s| s == name).unwrap()); let mut my_cols: Vec> = Vec::with_capacity(ordered_cols.len()); for (_, vals) in &ordered_cols { let mut out = Vec::with_capacity(m); for &row in &order { out.push(vals[row]); } my_cols.push(out); } // ---- 4) 谓词(可选)---- let pred = pred_text.map(|t| parse_pred(t, schema)).transpose()?; // ---- 5) 同一条 TCP 上进 Vault:先对表查询计划,再交换列分片 ---- let site_refs: Vec<&str> = sites.iter().map(|s| s.as_str()).collect(); let mut vault = Vault::new(&mut *transport, site, &site_refs, vault_seed, fxp).map_err(|e| e.to_string())?; // 计划对表:schema + 聚合列 + 谓词 + 对齐行数,**逐字段**比对。 // // 不对表的话,任一方参数不同(最常见的是一方漏了 `--pred`)会让后续 open 的 // 调用序列错位,报出来是「open 长度不一致: 本方 186,第 1 方 3」——完全看不出 // 是谁配错了。这些参数本来就是两方必须公开一致的,不新增泄露面。 // // 之所以不用「各出一份差值分片求和为零」的老办法:那只回答「不一样」, // 逐字段清单能回答「`pred` 不一致:本方有、对端没有」。 let extra = vec![ ("schema".to_string(), schema.join(",")), ("agg_col".to_string(), agg_col.to_string()), ( "pred".to_string(), pred_text.unwrap_or("").to_string(), ), ("aligned_rows".to_string(), m.to_string()), ]; vault.exchange_manifest(&extra).map_err(|e| e.to_string())?; let (mine, theirs) = exchange_split_columns(&mut vault, &my_cols, peer_slots.len()) .map_err(|e| e.to_string())?; if verbose { eprintln!( " 列分片交换完毕(本方 {} 列、对端 {} 列)", mine.len(), theirs.len() ); eprintln!( " 分片长度详情: mine={:?} theirs={:?}", mine.iter().map(|c| c.len()).collect::>(), theirs.iter().map(|c| c.len()).collect::>() ); } // 按 schema 槽位落位(不是 mine + theirs) let mut all_cols: Vec> = vec![Vec::new(); schema.len()]; for (k, c) in mine.into_iter().enumerate() { all_cols[my_slots[k]] = c; } for (k, c) in theirs.into_iter().enumerate() { all_cols[peer_slots[k]] = c; } // ---- 6) 密态聚合 ---- let aggs = [Agg::Count, Agg::Sum, Agg::Avg, Agg::Min, Agg::Max]; let vals = match &pred { Some(p) => secure_where_aggregate_pred(&mut vault, &all_cols, p, agg_idx, &aggs) .map_err(|e| e.to_string())?, None => secure_aggregate_all(&mut vault, &all_cols[agg_idx], &aggs) .map_err(|e| e.to_string())?, }; // 回传对齐后的键,供调用方交叉核验两方对齐一致 let aligned_ids: Vec = order.iter().map(|&i| ids[i]).collect(); Ok((aligned_ids, vals)) } /// 聚合结果的展示口径:每项一个表格单元格。 /// /// 屏幕输出和 `--report json` 共用这一份 —— 免得两条路径各格式化一次, /// 出现「屏幕上是 3、JSON 里是 3.0000000001」这种对不上的事。 /// /// COUNT 走整数格、其余走 4 位小数格;空集的 `SUM/AVG/MIN/MAX` 是 NaN, /// 统一成 `(空集)` 文本 / JSON `null`。 pub fn result_cells(vals: &[f64]) -> Vec<(&'static str, crate::report::Cell)> { use crate::report::Cell; let names = ["COUNT", "SUM", "AVG", "MIN", "MAX"]; names .iter() .zip(vals) .map(|(name, v)| { let cell = if v.is_nan() { Cell::empty("空集") } else if *name == "COUNT" { Cell::int(*v as i64) } else { Cell::nump(*v, 4) }; (*name, cell) }) .collect() } // --------------------------------------------------------------------------- // 真 TCP 两方端到端测试 // --------------------------------------------------------------------------- #[cfg(test)] mod tests { use super::*; use mpc_node::TcpTransport; use std::net::TcpListener; use std::thread; /// 两方数据:alice 持 `balance`、bob 持 `spend`,交集 = {2, 3, 4}。 /// /// 刻意让两方本地顺序**不同**(alice 乱序、bob 也乱序), /// 排序对齐才能让它俩逐行对上。 fn sample() -> ( (Vec, Vec<(String, Vec)>), (Vec, Vec<(String, Vec)>), ) { // alice: id=7,2,4,1,8,3 balance=700,200,400,100,800,300 let alice_ids = vec![7, 2, 4, 1, 8, 3]; let alice_cols = vec![("balance".to_string(), vec![700.0, 200.0, 400.0, 100.0, 800.0, 300.0])]; // bob: id=4,9,2,3,5 spend=40,90,20,30,50 let bob_ids = vec![4, 9, 2, 3, 5]; let bob_cols = vec![("spend".to_string(), vec![40.0, 90.0, 20.0, 30.0, 50.0])]; ((alice_ids, alice_cols), (bob_ids, bob_cols)) } /// 起两个线程,各持一个 TcpTransport,跑完整 `sql_join::run`。 fn run_pair( a_ids: &[u64], a_cols: &[(String, Vec)], b_ids: &[u64], b_cols: &[(String, Vec)], schema: &[String], agg_col: &str, pred: Option<&str>, ) -> ((Vec, Vec), (Vec, Vec)) { let listener = TcpListener::bind("127.0.0.1:0").unwrap(); let addr = listener.local_addr().unwrap().to_string(); let schema_a = schema.to_vec(); let schema_b = schema.to_vec(); let agg_a = agg_col.to_string(); let agg_b = agg_col.to_string(); let pred_a = pred.map(|s| s.to_string()); let pred_b = pred.map(|s| s.to_string()); let a_cols = a_cols.to_vec(); let b_cols = b_cols.to_vec(); let a_ids = a_ids.to_vec(); let b_ids = b_ids.to_vec(); // bob: accept(listener 已在主线程 bind,这里直接 accept) let hb = thread::spawn(move || { let (stream, _) = listener.accept().unwrap(); let mut t = TcpTransport::new(stream).unwrap(); run( "bob", &["alice".to_string(), "bob".to_string()], &mut t, &b_ids, &b_cols, &schema_b, &agg_b, pred_b.as_deref(), [0x22u8; 32], // PSI 种子:每方不同 [0x5Bu8; 32], // Vault 种子:两方一致 18, false, ) .unwrap() }); // alice: connect let ha = thread::spawn(move || { let mut t = TcpTransport::connect(&addr, 50).unwrap(); run( "alice", &["alice".to_string(), "bob".to_string()], &mut t, &a_ids, &a_cols, &schema_a, &agg_a, pred_a.as_deref(), [0x11u8; 32], // PSI 种子:每方不同 [0x5Bu8; 32], // Vault 种子:两方一致 18, false, ) .unwrap() }); let ra = ha.join().expect("alice 线程"); let rb = hb.join().expect("bob 线程"); (ra, rb) } /// 无 WHERE:COUNT / SUM / AVG / MIN / MAX 全部对拍。 #[test] fn tcp_join_count_sum_matches() { let ((ai, ac), (bi, bc)) = sample(); let schema = vec!["balance".to_string(), "spend".to_string()]; let ((keys_a, va), (keys_b, vb)) = run_pair(&ai, &ac, &bi, &bc, &schema, "balance", None); // 对齐后键序列 = 2, 3, 4(键字节序) assert_eq!(keys_a, vec![2, 3, 4], "alice 对齐键序"); assert_eq!(keys_b, vec![2, 3, 4], "bob 对齐键序"); // 对齐后 balance = [200, 300, 400],spend = [20, 30, 40] // COUNT=3, SUM=900, AVG=300, MIN=200, MAX=400 let want = [3.0, 900.0, 300.0, 200.0, 400.0]; for (i, (a, b)) in va.iter().zip(&vb).enumerate() { assert!((a - b).abs() < 1e-6, "两方结果不一致 [{i}]: {a} vs {b}"); // AVG 走 fxp truncate,精度 ~1e-3(与 secure.rs 的 AVG 容差一致) let tol = if i == 2 { 1e-2 } else { 1e-4 }; assert!((a - want[i]).abs() < tol, "[{i}] got {a} want {}", want[i]); } } /// 列 vs 列 WHERE:`balance > spend`。 /// /// 对齐后:key2: 200>20 ✓、key3: 300>30 ✓、key4: 400>40 ✓ → 全命中 /// 换个不对齐就红的数据:如果排序坏了,行会错位。 #[test] fn tcp_join_where_col_vs_col() { let ((ai, ac), (bi, bc)) = sample(); let schema = vec!["balance".to_string(), "spend".to_string()]; let ((_, va), (_, vb)) = run_pair(&ai, &ac, &bi, &bc, &schema, "balance", Some("balance > spend")); // 全命中 → COUNT=3, SUM=900 assert_eq!(va[0], 3.0, "COUNT"); assert!((va[1] - 900.0).abs() < 1e-4, "SUM {}", va[1]); // 两方结果一致 for (a, b) in va.iter().zip(&vb) { assert!((a - b).abs() < 1e-6, "两方不一致: {a} vs {b}"); } } /// 列 vs 常量 WHERE:`balance >= 250`。 /// /// 对齐后 balance = [200, 300, 400] → 命中 key3, key4 → COUNT=2, SUM=700 #[test] fn tcp_join_where_const() { let ((ai, ac), (bi, bc)) = sample(); let schema = vec!["balance".to_string(), "spend".to_string()]; let ((_, va), (_, vb)) = run_pair(&ai, &ac, &bi, &bc, &schema, "balance", Some("balance >= 250")); assert_eq!(va[0], 2.0, "COUNT"); assert!((va[1] - 700.0).abs() < 1e-4, "SUM {}", va[1]); for (a, b) in va.iter().zip(&vb) { assert!((a - b).abs() < 1e-6, "两方不一致: {a} vs {b}"); } } /// 空交集必须显式失败,不能静默返回 0。 #[test] fn tcp_join_disjoint_fails() { let a_ids = vec![1u64, 2, 3]; let a_cols = vec![("balance".to_string(), vec![1.0, 2.0, 3.0])]; let b_ids = vec![7u64, 8, 9]; let b_cols = vec![("spend".to_string(), vec![7.0, 8.0, 9.0])]; let schema_a = vec!["balance".to_string(), "spend".to_string()]; let schema_b = schema_a.clone(); let listener = TcpListener::bind("127.0.0.1:0").unwrap(); let addr = listener.local_addr().unwrap().to_string(); let hb = thread::spawn(move || { let (stream, _) = listener.accept().unwrap(); let mut t = TcpTransport::new(stream).unwrap(); run( "bob", &["alice".to_string(), "bob".to_string()], &mut t, &b_ids, &b_cols, &schema_b, "spend", None, [0x22u8; 32], [0x5Bu8; 32], 18, false, ) }); let ha = thread::spawn(move || { let mut t = TcpTransport::connect(&addr, 50).unwrap(); run( "alice", &["alice".to_string(), "bob".to_string()], &mut t, &a_ids, &a_cols, &schema_a, "balance", None, [0x11u8; 32], [0x5Bu8; 32], 18, false, ) }); let ra = ha.join().unwrap(); let rb = hb.join().unwrap(); assert!(ra.is_err(), "alice 应报错(空交集): {ra:?}"); assert!(rb.is_err(), "bob 应报错(空交集): {rb:?}"); assert!( ra.unwrap_err().contains("交集为空"), "错误应指出交集为空" ); } /// 两方参数不一致(这里是最常见的:一方漏了 `--pred`)必须在**动手算之前**被点出来, /// 而不是等到 open 序列错位报「长度不一致」——后者看不出是谁配错了。 #[test] fn tcp_join_plan_mismatch_is_diagnosed() { let ((ai, ac), (bi, bc)) = sample(); let schema_a = vec!["balance".to_string(), "spend".to_string()]; let schema_b = schema_a.clone(); let listener = TcpListener::bind("127.0.0.1:0").unwrap(); let addr = listener.local_addr().unwrap().to_string(); let sites = vec!["alice".to_string(), "bob".to_string()]; let (sites_a, sites_b) = (sites.clone(), sites.clone()); let hb = thread::spawn(move || { let (stream, _) = listener.accept().unwrap(); let mut t = TcpTransport::new(stream).unwrap(); // bob 漏了谓词 run( "bob", &sites_b, &mut t, &bi, &bc, &schema_b, "spend", None, [0x22u8; 32], [0x5Bu8; 32], 18, false, ) }); let ha = thread::spawn(move || { let mut t = TcpTransport::connect(&addr, 50).unwrap(); run( "alice", &sites_a, &mut t, &ai, &ac, &schema_a, // agg_col 两边一致,让**唯一**的差异是 pred —— 否则对表会先揪出 // agg_col,这条断言就永远测不到「漏谓词」这个真实场景 "spend", Some("balance >= 250"), [0x11u8; 32], [0x5Bu8; 32], 18, false, ) }); let ea = ha.join().unwrap().unwrap_err(); let eb = hb.join().unwrap().unwrap_err(); // 两侧都必须点名是哪个参数不一致,而不是笼统说「计划不一致」 assert!(ea.contains("pred"), "alice 的错误要点名 pred: {ea}"); assert!(eb.contains("pred"), "bob 的错误要点名 pred: {eb}"); } }