Files
ssw-mpc/crates/mpc-cli/src/sql_join.rs
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

601 lines
22 KiB
Rust
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.
//! `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<f64>), 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<f64> = rest
.split(',')
.map(|t| t.trim().parse::<f64>().map_err(|_| format!("--data {name:?} 里 {t:?} 不是浮点")))
.collect::<Result<_, _>>()?;
if vals.is_empty() {
return Err(format!("--data {name:?} 没有值"));
}
Ok((name, vals))
}
/// 解析 `--schema col1,col2,...` 为全局列名数组。
pub fn parse_schema(spec: &str) -> Result<Vec<String>, String> {
let names: Vec<String> = 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<Pred, String> {
let find = |s: &str| -> Result<usize, String> {
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<f64>)],
schema: &[String],
agg_col: &str,
pred_text: Option<&str>,
psi_seed: [u8; 32],
vault_seed: [u8; 32],
fxp: u32,
verbose: bool,
) -> Result<(Vec<u64>, Vec<f64>), 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::<Vec<_>>();
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<usize> = cols
.iter()
.map(|(name, _)| {
schema
.iter()
.position(|s| s == name)
.expect("上面已校验在 schema 里")
})
.collect();
my_slots.sort_unstable();
// 对端列占剩下的 schema 槽位
let peer_slots: Vec<usize> = (0..schema.len()).filter(|i| !my_slots.contains(i)).collect();
let keys: Vec<Vec<u8>> = 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<f64>)> = cols.iter().collect();
ordered_cols.sort_by_key(|(name, _)| schema.iter().position(|s| s == name).unwrap());
let mut my_cols: Vec<Vec<f64>> = 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("<none>").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::<Vec<_>>(),
theirs.iter().map(|c| c.len()).collect::<Vec<_>>()
);
}
// 按 schema 槽位落位(不是 mine + theirs)
let mut all_cols: Vec<Vec<u64>> = 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<u64> = 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<u64>, Vec<(String, Vec<f64>)>),
(Vec<u64>, Vec<(String, Vec<f64>)>),
) {
// 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<f64>)],
b_ids: &[u64],
b_cols: &[(String, Vec<f64>)],
schema: &[String],
agg_col: &str,
pred: Option<&str>,
) -> ((Vec<u64>, Vec<f64>), (Vec<u64>, Vec<f64>)) {
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}");
}
}