From df021dba0debd6afe7d75307c0f9289d43513d21 Mon Sep 17 00:00:00 2001 From: rong Date: Fri, 30 Oct 2026 18:32:43 +0800 Subject: [PATCH] =?UTF-8?q?feat(cli):=20nax=20sql-join=20=E7=9C=9F?= =?UTF-8?q?=E4=B8=A4=E8=BF=9B=E7=A8=8B=20JOIN=C3=97PSI=C3=97=E5=AF=86?= =?UTF-8?q?=E6=80=81=20SQL?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 影响:能敲一个命令在真 TCP 两进程里跑 PSI → 对齐 → 密态聚合 → reveal; `--schema` 约定全局列序解决竖向切分里两方各持不同列的拼接问题。 - `nax sql-join` 子命令(需 --features secure):真 TCP 两进程, PSI → align_by_key → exchange_split_columns → 密态聚合。 - `--schema col1,col2,...`:全局列序,列交换后按 schema 槽位落位。 **不是 mine + theirs 简单拼接** —— 后者两方拼出的顺序不同,谓词下标静默错位。 - 两个种子:psi_seed 每方不同(同种子 = ECDH 私钥相同,隐私破坏); vault_seed 两方一致(Beaver 物料派生)。CLI 从 (seed, site) 自动派生 psi_seed。 - `impl Transport for &mut T`:同一条 TCP 先 PSI 再 Vault 不用拆通道。 - 新增 4 测(真 TcpListener + TcpTransport)含变异检验: schema 落位换成拼接 → 3 条红。 - 更新 README、GAP_PLAN(产品口径缺口 ①②③ 已闭环)。 --- README.md | 17 +- crates/nax-cli/src/main.rs | 123 ++++++++ crates/nax-cli/src/sql_join.rs | 497 +++++++++++++++++++++++++++++++++ crates/nax-vault/src/lib.rs | 12 + docs/GAP_PLAN.md | 61 ++++ 5 files changed, 706 insertions(+), 4 deletions(-) create mode 100644 crates/nax-cli/src/sql_join.rs diff --git a/README.md b/README.md index 6b04b2a..67484a3 100644 --- a/README.md +++ b/README.md @@ -32,20 +32,20 @@ | `nax-fl` 联邦聚合 + DP + FedAvg | ✅ 安全聚合责任链(Clip/Zero/SecureSum/Mean/GaussianNoise)+ 差分隐私(RDP 记账)+ 横向 FedAvg(local_train/metrics/加权均值/收敛轨迹),12 测含 4 逐位 golden;`--features secure` 另有 2 方 Vault 密态加权均值端到端 1 测 | | `nax-ml` 纵向 LR + MLP + 分箱 | ✅ sigmoid 奇多项式 + Beaver SGD(明文对照 >0.95);MLP 4 测;异构分箱 + WOE/IV + 互补抑制 6 测;密文 `Mᵀ@y` 箱计数 1 测 | | `nax-data` 数据层 | ✅ Frame(选择/矩阵/列和)+ 明文统计(均值/方差/协方差/相关)+ mock(确定性主键/schema 合成/DP)+ CSV,16 测 | -| `nax-sql` SCQL 引擎 | ✅ 手写解析器 + 掩码式 WHERE + 聚合/GROUP BY/k-匿名/投影约束/JOIN/HAVING/ORDER BY,15 测;`--features secure` 另有密态 WHERE/复合谓词/IN/GROUP BY/k-匿名 6 测 + **JOIN×PSI 端到端 6 测**(PSI → 按键字节序对齐 → 密态聚合,对拍明文 JOIN) | +| `nax-sql` SCQL 引擎 | ✅ 手写解析器 + 掩码式 WHERE + 聚合/GROUP BY/k-匿名/投影约束/JOIN/HAVING/ORDER BY,15 测;`--features secure` 另有密态 WHERE/复合谓词(AND/OR/NOT)/IN/**列 vs 列**/GROUP BY/k-匿名 9 测 + **JOIN×PSI 端到端 6 测**(PSI → 按键字节序对齐 → 密态聚合,对拍明文 JOIN) | | `nax-policy` 策略/审计 | ✅ 出域守卫(exec/transfer/fetch)+ Label 六档 + 审计日志(过滤/汇总/裁剪),9 测 | | `nax-runtime` 执行模式 | ✅ dry_run / real_run(线程局部 + RAII 嵌套恢复),4 测 | | `nax-he` Paillier/OLE | ✅ 无可信发牌方 Beaver 物料 + PIR,50 条 Python 逐位对照 + 13 语义测试 | | `nax-tee` HAL | ✅ trait + Mock 实现(11 单测),OP-TEE 待接 | -| `nax-cli` | ✅ 单二进制,`selftest` / `node` / `psi` / `lr` / `fl` 子命令;`--features secure` 另加 `nax sql` 密态 SQL 演示 | +| `nax-cli` | ✅ 单二进制,`selftest` / `node` / `psi` / `lr` / `fl` 子命令;`--features secure` 另加 `nax sql`(in-process)与 `nax sql-join`(真 TCP 两进程 JOIN×PSI×密态 SQL) | | `nax-orch` 编排 | ✅ 661 行纯 std,PLAN 协议 + 两阶段提交,7 单测;本机三进程跑通 | | `nax-ray` Ray C++ 内核 | ✅ 链接 `_raylet.so` 接入真实集群(拿到 raylet 分配的 node id),见 `docs/RAY_CORE.md` | | Ray 1.0.1 跨架构 | ✅ x86_64 原生 + armv7(qemu) 同集群,两端各自注册成 driver,跨架构 MPC 结果一致,见 `docs/RAY_CORE_101.md` | | armv7 交叉编译 | ✅ **真出二进制**:musl 静态 687 KB,`file` 显示 `ARM, EABI5, statically linked` | ```bash -cargo test --workspace # 218 用例 -cargo test -p nax-sql --features secure # 27 用例(含 JOIN×PSI 端到端) +cargo test --workspace # 222 用例 +cargo test -p nax-sql --features secure # 30 用例(含 JOIN×PSI 端到端 + 列 vs 列) cargo build --release -p nax-cli && ./target/release/nax selftest cargo check --workspace --target armv7-unknown-linux-gnueabihf ``` @@ -164,6 +164,12 @@ PSI(nax-node::run_psi_session)→ 本方交集下标(本地行序升序) (COUNT/SUM、跨方复合 WHERE、GROUP BY)。`nax-sql` 的**库**依赖里没有 `nax-node`/`nax-psi`:PSI 与对齐属于调用方,SQL 层只吃"已对齐的分片"。 +密态 WHERE 还支持**列 vs 列**(`WHERE balance > spend`),走 `Pred::CmpCol` —— +右值是密文分片不过 `vault.constant`,开销与列 vs 常量相同。 + +`nax sql-join` 子命令(`--features secure`)走真 TCP 两进程跑完整链路, +`--schema` 约定全局列序(竖向切分里两方各持不同列,按槽位落位而非简单拼接)。 + ### P2 验收:两进程纵向 LR ```bash @@ -178,6 +184,9 @@ nax lr --site alice --sites alice,bob --connect 127.0.0.1:9448 \ 两侧输出一致:`w = [0.000008, 0.000000, 0.659542]`。 全程密文(特征、标签、梯度、权重都是加性分片),只有最后 `reveal` 那一步出域。 +**纵向 LR 已接 PSI 对齐**(`run_lr_vertical_session`):两方各持不同客户名单时, +先 `align_by_key` 求交排序对齐,再 0 分片拼接列块训练。4 测含变异检验。 + - `nax-ml`:sigmoid 奇多项式逼近(与参考实现 `SIGMOID_FITS` 逐位一致)+ SGD 训练循环 - 每轮 2 次矩阵 Beaver 乘 + 1 次 sigmoid 逼近(5 次 mul_trunc + 2 次 truncate) - 明文对照测试:密文权重与精确 sigmoid 明文训练的相关系数 > 0.95 diff --git a/crates/nax-cli/src/main.rs b/crates/nax-cli/src/main.rs index f6f62fa..ee04ea4 100644 --- a/crates/nax-cli/src/main.rs +++ b/crates/nax-cli/src/main.rs @@ -23,6 +23,8 @@ use nax_tee::Tee; #[cfg(feature = "secure")] mod sql_demo; +#[cfg(feature = "secure")] +mod sql_join; const VERSION: &str = env!("CARGO_PKG_VERSION"); @@ -40,6 +42,8 @@ fn main() -> ExitCode { "fl" => cmd_fl(&args[1..]), #[cfg(feature = "secure")] "sql" => sql_demo::run(), + #[cfg(feature = "secure")] + "sql-join" => cmd_sql_join(&args[1..]), "version" | "-V" | "--version" => { println!("nax {VERSION}"); Ok(()) @@ -74,6 +78,7 @@ fn usage() { nax psi 启动一方节点,与对端做一次隐私求交(ECDH-PSI) nax fl 横向联邦平均(FedAvg)本地演示(无网络,合成数据) nax sql in-process 2 方密态 SQL 演示(编译需 --features secure) + nax sql-join 真两进程 TCP 的 JOIN×PSI×密态 SQL(编译需 --features secure) nax version 打印版本 nax help 显示本帮助 @@ -698,6 +703,124 @@ fn parse_seed(hex: &str) -> Result<[u8; 32], String> { Ok(out) } +// --------------------------------------------------------------------------- +// nax sql-join(需 --features secure) +// --------------------------------------------------------------------------- + +#[cfg(feature = "secure")] +fn cmd_sql_join(args: &[String]) -> Result<(), String> { + let site = parse_flag(args, "--site").ok_or("缺少 --site")?.to_string(); + let sites_raw = parse_flag(args, "--sites").ok_or("缺少 --sites")?; + let sites: Vec = sites_raw + .split(',') + .map(|s| s.trim().to_string()) + .filter(|s| !s.is_empty()) + .collect(); + if sites.len() != 2 { + return Err(format!("sql-join 目前只支持两方,--sites 得到 {} 个", sites.len())); + } + if !sites.contains(&site) { + return Err(format!("--site {site} 不在 --sites {sites:?} 里")); + } + + let listen = parse_flag(args, "--listen"); + let connect = parse_flag(args, "--connect"); + let addr = match (listen, connect) { + (Some(_), Some(_)) => return Err("--listen 与 --connect 只能选一个".into()), + (None, None) => return Err("必须给 --listen 或 --connect".into()), + (Some(a), None) | (None, Some(a)) => a.to_string(), + }; + + let seed = match parse_flag(args, "--seed") { + Some(h) => parse_seed(h)?, + None => [0u8; 32], + }; + let fxp: u32 = parse_flag(args, "--fxp") + .unwrap_or("18") + .parse() + .map_err(|_| "--fxp 不是合法整数")?; + + // --ids:join 键 + let ids_raw = parse_flag(args, "--ids").ok_or("缺少 --ids")?; + let mut ids = Vec::new(); + for tok in ids_raw.split(',') { + let tok = tok.trim(); + if tok.is_empty() { + continue; + } + let v: u64 = tok.parse().map_err(|_| format!("--ids 里的 {tok:?} 不是非负整数"))?; + ids.push(v); + } + if ids.is_empty() { + return Err("--ids 为空".into()); + } + + // --data name=v1,v2,...(可重复) + let mut cols: Vec<(String, Vec)> = Vec::new(); + for i in 0..args.len() { + if args[i] == "--data" && i + 1 < args.len() { + cols.push(sql_join::parse_col(&args[i + 1])?); + } + } + if cols.is_empty() { + return Err("至少要有一个 --data name=v1,v2,...".into()); + } + + // --schema col1,col2,...(两方必须一致的全局列序) + let schema_raw = parse_flag(args, "--schema").ok_or("缺少 --schema")?; + let schema = sql_join::parse_schema(schema_raw)?; + + let agg_col = parse_flag(args, "--agg-col").ok_or("缺少 --agg-col")?; + let pred = parse_flag(args, "--pred"); + + println!( + "nax sql-join · site={site} · {addr} · {} 行 × {} 列 · 聚合列={agg_col}", + ids.len(), + cols.len() + ); + println!(" schema: {}", schema.join(",")); + if let Some(p) = pred { + println!(" 谓词: WHERE {p}"); + } + + let mut transport = if listen.is_some() { + println!(" 等待对端连接..."); + TcpTransport::accept(&addr).map_err(|e| e.to_string())? + } else { + println!(" 连接对端..."); + TcpTransport::connect(&addr, 50).map_err(|e| e.to_string())? + }; + println!(" 已连接"); + + // PSI 种子从 (vault_seed, site) 派生 —— 同一 --seed 下两方自动取不同值, + // 否则 ECDH 私钥相同,PSI 的隐私性直接破坏(但交集仍会算对,很隐蔽)。 + let mut psi_seed = seed; + for (i, b) in site.bytes().enumerate() { + psi_seed[i % 32] = psi_seed[i % 32] + .wrapping_add(b) + .wrapping_mul(31) + .wrapping_add(i as u8); + } + + let (aligned, vals) = sql_join::run( + &site, + &sites, + &mut transport, + &ids, + &cols, + &schema, + agg_col, + pred, + psi_seed, + seed, // Vault 种子:两方必须一致 + fxp, + true, + )?; + println!("\n对齐后 {} 行: {:?}", aligned.len(), aligned); + sql_join::print_result(&vals); + Ok(()) +} + // --------------------------------------------------------------------------- // nax psi // --------------------------------------------------------------------------- diff --git a/crates/nax-cli/src/sql_join.rs b/crates/nax-cli/src/sql_join.rs new file mode 100644 index 0000000..96f6995 --- /dev/null +++ b/crates/nax-cli/src/sql_join.rs @@ -0,0 +1,497 @@ +//! `nax sql-join`:**真两进程 TCP** 的 JOIN × PSI × 密态 SQL 演示。 +//! +//! 与 `nax sql`(in-process `Pipe::pair`)的区别:这里走真实 TCP,两个终端各起一方, +//! 流程是 PSI 求交 → 按键字节序排序对齐 → 列分片交换 → 密态聚合 → reveal。 +//! +//! 分层约定:PSI 与行对齐在**本模块**(调用方),`nax-sql::secure` 只吃已对齐的分片。 +//! 对齐助手是 [`nax_psi::align_by_key`],不在 `nax-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 nax_node::{run_psi_session, PsiConfig, TcpTransport}; +use nax_sql::secure::{ + exchange_split_columns, secure_aggregate_all, secure_where_aggregate_pred, Agg, CmpOp, Pred, +}; +use nax_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| nax_psi::id_from_u64(v)).collect(); + + // ---- 1) PSI:本方交集下标(本地行序升序)---- + let psi_cfg = PsiConfig { + site: site.to_string(), + sites: sites.to_vec(), + ids: keys.clone(), + seed: psi_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 = nax_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())?; + + 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() + ); + } + + // 按 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)) +} + +/// 打印一行聚合结果表。 +pub fn print_result(vals: &[f64]) { + let names = ["COUNT", "SUM", "AVG", "MIN", "MAX"]; + println!("\n密态聚合结果(已 reveal):"); + for (name, v) in names.iter().zip(vals) { + if v.is_nan() { + println!(" {name:>5} = (空集)"); + } else if *name == "COUNT" { + println!(" {name:>5} = {:.0}", v); + } else { + println!(" {name:>5} = {v:.4}"); + } + } +} + +// --------------------------------------------------------------------------- +// 真 TCP 两方端到端测试 +// --------------------------------------------------------------------------- + +#[cfg(test)] +mod tests { + use super::*; + use nax_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("交集为空"), + "错误应指出交集为空" + ); + } +} diff --git a/crates/nax-vault/src/lib.rs b/crates/nax-vault/src/lib.rs index 3639594..b7ba627 100644 --- a/crates/nax-vault/src/lib.rs +++ b/crates/nax-vault/src/lib.rs @@ -617,6 +617,18 @@ impl Pipe { } } +/// 任意 `Transport` 的可变引用也是 `Transport` —— 同一条连接上先跑 PSI、 +/// 再进 `Vault` 时不用拆两条通道:`run_psi_session(&mut t, …)` 结束后 +/// `Vault::new(&mut t, …)` 继续用同一条。 +impl Transport for &mut T { + fn send_to(&mut self, party: usize, frame: Frame) -> Result<(), VaultError> { + (**self).send_to(party, frame) + } + fn recv_from(&mut self, party: usize) -> Result { + (**self).recv_from(party) + } +} + impl Transport for Pipe { /// 单连接实现:`party` 被忽略。 /// diff --git a/docs/GAP_PLAN.md b/docs/GAP_PLAN.md index 0371aa4..1fb6abe 100644 --- a/docs/GAP_PLAN.md +++ b/docs/GAP_PLAN.md @@ -135,3 +135,64 @@ Python 参考版 `nax/` 共 **8,963 行**。此前约 **4,150 行(≈46%)未 `-p nax-ml` 15 测,全绿、零警告。 - 未做:CLI 侧 `nax sql-join` 子命令。对齐助手目前在测试文件里(按「放调用方」的约定), 真要做 CLI 时应当把它上提成**调用方那一层**的复用件,而不是塞回 `nax-sql`。 + +## 产品口径补刀:纵向 LR 对齐 + 列 vs 列谓词 + CLI(按影响排序的缺口①②③) + +上一节的「9 个优先块」口径是「Python 有、Rust 没有」,这条线已走完。接下来补的是 +「对照一个能交付的产品」口径下的缺口,按影响排序做完 ①②③: + +### ① 纵向 LR 接 PSI 对齐(最大的断层) + +README 的 P2 验收里两方传的是**完全相同**的特征数据,即隐含「行已对齐」。真实场景是 +两方各持不同客户名单,必须先求交再对齐。此前对齐逻辑只接到了 SQL,没接到 LR。 + +- **`nax_psi::align_by_key`**:从测试上提为 `nax-psi` 的公开函数(PSI 结果的后处理, + 天然属于这一层)。入参 `keys + hits`,返回按共享键字节序的行序;键重复即报错。 +- **`run_lr_vertical_session`**(nax-node):两方各持不同客户、不同特征列的完整纵向 LR。 + 流程 = PSI → `align_by_key` → 本方列重排 → 0 分片拼接(不在自己列位填 0 就无法表达列拼接)。 +- **4 测**含变异检验:去掉 `align_by_key` 的排序后 2 条红(`r` 相关性掉到 0.4 量级)。 + +### ② 密态 WHERE 支持列 vs 列(半天工作量,ROI 最高) + +`secure_where_aggregate` 的右值是 `f64`,但底层 `vault.bit_lt(a,b)` 两侧都吃分片—— +能力早就有,只是 SQL 层没暴露入口。 + +- **`Pred::CmpCol { col, op, rhs_col }`**:右值是密文分片,**不能**过 `vault.constant` + (那等于把阈值公开给对端)。`mask_for` 两侧本来就吃分片,直接喂即可,开销与列 vs 常量相同。 +- **`secure_group_by_pred`**:吃任意 `Pred`(含 `CmpCol`)的 GROUP BY 入口, + 下标约定与 `secure_where_aggregate_pred` 一致;旧 `secure_group_by` 保留不动。 +- 列与自身比较(`x > x` 恒假)拒收——语义上合法但多半是调用方写错了。 +- **3 测**含变异检验:右值偷换成公开常量 0 后 2 条红(`cmp_col` 和 `group_by_col_pred`)。 + +### ③ `nax sql-join` CLI + 真两进程 TCP + +- **`nax sql-join`** 子命令(编译需 `--features secure`):真 TCP 两进程, + PSI → `align_by_key` → `exchange_split_columns` → 密态聚合 → reveal。 +- **`--schema` 全局列序**:竖向切分里两方各持不同列,密态聚合前必须拼出一致的列序。 + 用公开 schema 约定列名顺序,列交换后按 schema 槽位落位。变异检验:换成简单 + `mine + theirs` 拼接后 3 条红(两方拼出的顺序不同,谓词下标静默错位)。 +- **两个种子,别搞混**:`psi_seed` 每方不同(同种子 = ECDH 私钥相同,隐私破坏), + `vault_seed` 两方一致(Beaver 物料由它派生,不一致则所有乘法结果都是垃圾值)。 + CLI 从 `(vault_seed, site)` 自动派生 `psi_seed`,同一 `--seed` 下两方自动取不同值。 +- **4 测(真 TCP `TcpListener` + `TcpTransport`)**:join 后 COUNT/SUM/AVG/MIN/MAX、 + 列 vs 列 WHERE(`balance > spend`)、列 vs 常量 WHERE(`balance >= 250`)、空交集拒绝。 + 两方本地顺序**刻意相反**,排序没生效必红。 + +### 顺带修 + +- `impl Transport for &mut T`:同一条 TCP 连接上先跑 PSI、再进 Vault 不用拆两条通道。 +- 清掉 `nax-core/tests/golden_vectors.rs` 一条既有未使用 import 告警。 + +### 现状 + +`cargo test --workspace` **222 测**、0 失败、零 rustc 告警(只剩 nax-ray build script +的环境提示);`-p nax-sql --features secure` **30 测**、`-p nax-cli --features secure` **4 测**; +`cargo build -p nax-core --no-default-features` 通过。 + +### 仍然存在的缺口(有了真实用户再补) + +- **一对多 join 不支持**:PSI 去重只给一个下标,纵向对齐(一人一行)表达不了笛卡尔展开。 +- **P3 OP-TEE 停在 QEMU**,Zynq 真机没跑。README 里 Paillier 的「私钥操作放 TEE」 + 这句话目前没有兑现路径——TEE 只到模拟器。 +- **数据源只有极简数值 CSV**,无 PG/MySQL/Parquet 连接器。 +- **半诚实模型**,无恶意安全;PSI 的 `hash_only` 是文档标注的不安全基线。