feat(cli): nax sql-join 真两进程 JOIN×PSI×密态 SQL
影响:能敲一个命令在真 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(产品口径缺口 ①②③ 已闭环)。
This commit is contained in:
1 parent
b3baeb8690
commit
df021dba0d
5 files changed
+706
-4
No files matched your search
@@ -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
|
||||
|
||||
@@ -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<String> = 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<f64>)> = 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
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
@@ -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<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| 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<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())?;
|
||||
|
||||
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<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))
|
||||
}
|
||||
|
||||
/// 打印一行聚合结果表。
|
||||
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<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("交集为空"),
|
||||
"错误应指出交集为空"
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -617,6 +617,18 @@ impl Pipe {
|
||||
}
|
||||
}
|
||||
|
||||
/// 任意 `Transport` 的可变引用也是 `Transport` —— 同一条连接上先跑 PSI、
|
||||
/// 再进 `Vault` 时不用拆两条通道:`run_psi_session(&mut t, …)` 结束后
|
||||
/// `Vault::new(&mut t, …)` 继续用同一条。
|
||||
impl<T: Transport> 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<Frame, VaultError> {
|
||||
(**self).recv_from(party)
|
||||
}
|
||||
}
|
||||
|
||||
impl Transport for Pipe {
|
||||
/// 单连接实现:`party` 被忽略。
|
||||
///
|
||||
|
||||
@@ -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` 是文档标注的不安全基线。
|
||||
Reference in new issue
Block a user