diff --git a/crates/nax-sql/src/secure.rs b/crates/nax-sql/src/secure.rs index 83852a1..a38d513 100644 --- a/crates/nax-sql/src/secure.rs +++ b/crates/nax-sql/src/secure.rs @@ -197,12 +197,74 @@ pub fn secure_group_by( Ok(out) } +/// 密态 GROUP BY(谓词版):`pred` 是任意复合谓词(含 [`Pred::CmpCol`] 列 vs 列)。 +/// +/// `cols` 是参与谓词求值的全部列分片;`agg_col` 是聚合目标在 `cols` 里的下标, +/// `gcol` 是已编码到 `0..n_groups-1` 的分组码分片。 +/// +/// 与 [`secure_group_by`] 的区别只在 WHERE 谓词的表达力:这里右值可以是 +/// 另一列的密文分片(`WHERE balance > spend`),不需要公开阈值。 +/// 下标约定与 [`secure_where_aggregate_pred`] 一致。 +pub fn secure_group_by_pred( + vault: &mut Vault, + cols: &[Vec], + agg_col: usize, + gcol: &[u64], + n_groups: usize, + pred: Option<&Pred>, + aggs: &[Agg], + min_group_size: usize, +) -> Result>, VaultError> { + let col = cols + .get(agg_col) + .ok_or_else(|| VaultError::Protocol(format!("聚合列 {agg_col} 不存在")))?; + let len = col.len(); + if gcol.len() != len { + return Err(VaultError::Protocol(format!( + "聚合列有 {len} 行、分组列有 {} 行 —— 行对齐没做干净", + gcol.len() + ))); + } + // 基础掩码:WHERE 或全 1 + let base = match pred { + Some(p) => secure_predicate_mask(vault, cols, p)?, + None => vault.bit_one(len), + }; + if base.len() != len { + return Err(VaultError::Protocol("谓词掩码与分组列长度不一致".into())); + } + + let mut out = Vec::with_capacity(n_groups); + for g in 0..n_groups { + let gc = vault.constant(g as f64, len)?; + let gmask = vault.bit_eq(gcol, &gc)?; + let mask = vault.bit_and(&base, &gmask)?; + let (count, vals) = aggregate_with_mask(vault, col, &mask, aggs)?; + if min_group_size > 0 && count < min_group_size { + out.push(vec![f64::NAN; aggs.len()]); // 整行抑制 + } else { + out.push(vals); + } + } + Ok(out) +} + /// 复合谓词:列与字面量的比较,用 AND / OR / NOT 组合。 /// /// 对应明文引擎 `_eval_binop` 里 AND/OR/NOT 的位运算;`col` 是 `cols` 切片的下标。 #[derive(Clone, Debug)] pub enum Pred { Cmp { col: usize, op: CmpOp, threshold: f64 }, + /// `col rhs_col` —— **列与列**比较,两侧都是密文分片。 + /// + /// 与 [`Pred::Cmp`] 的区别只在右值:这里右值不是公开常量,所以不能走 + /// `vault.constant`(那等于把比较阈值直接告诉对端)。底层 `mask_for` + /// 本来两侧就吃分片,因此把 `cols[rhs_col]` 直接喂进去即可 —— + /// **不需要额外协议轮次**,开销与列 vs 常量完全相同。 + /// + /// `col == rhs_col` 在语义上合法(`x < x` 恒假、`x = x` 恒真), + /// 但会白跑一轮比较,调用方大概率是写错了。 + CmpCol { col: usize, op: CmpOp, rhs_col: usize }, /// `col IN (v1, v2, …)`,脱糖成若干 `=` 的 OR;`negated` 时再取反。 In { col: usize, values: Vec, negated: bool }, And(Box, Box), @@ -224,6 +286,29 @@ pub fn secure_predicate_mask( let th = vault.constant(*threshold, c.len())?; mask_for(vault, c, &th, *op) } + Pred::CmpCol { col, op, rhs_col } => { + if col == rhs_col { + return Err(VaultError::Protocol(format!( + "列与自身比较(列 {col})—— 语义上恒定,多半是写错了" + ))); + } + let c = cols + .get(*col) + .ok_or_else(|| VaultError::Protocol(format!("谓词引用了不存在的列 {col}")))?; + let rhs = cols.get(*rhs_col).ok_or_else(|| { + VaultError::Protocol(format!("谓词右值引用了不存在的列 {rhs_col}")) + })?; + if c.len() != rhs.len() { + return Err(VaultError::Protocol(format!( + "列 {col} 有 {} 行、右值列 {rhs_col} 有 {} 行 —— 行对齐没做干净", + c.len(), + rhs.len() + ))); + } + // 右值是密文分片,**不能**过 `vault.constant`(那会把比较阈值 + // 公开给对端)。`mask_for` 两侧本来就吃分片,直接喂。 + mask_for(vault, c, rhs, *op) + } Pred::In { col, values, @@ -673,4 +758,183 @@ mod tests { assert_eq!(got[1][0], 3.0, "组1 COUNT"); assert!((got[1][1] - 90.0).abs() < 1e-6, "组1 SUM {}", got[1][1]); } + + /// 列 vs 列:`WHERE balance > spend` 密态对拍明文引擎。 + /// + /// 右值是**密文分片**不是公开常量,所以走 [`Pred::CmpCol`] —— 这条路径 + /// 不能过 `vault.constant`(那会把比较阈值直接告诉对端)。 + #[test] + fn secure_cmp_col_matches_engine() { + let balance = [100.0f64, 500.0, 250.0, 600.0, 300.0]; + let spend = [50.0f64, 400.0, 300.0, 200.0, 300.0]; + let aggs = [Agg::Count, Agg::Sum, Agg::Min, Agg::Max]; + + let t = Table::new("t", "alice") + .with_col("balance", ColData::Num(balance.to_vec())) + .with_col("spend", ColData::Num(spend.to_vec())); + let mut e = Engine::new(0); + e.register(t); + let rt = e + .sql("SELECT COUNT(*) AS n, SUM(balance) AS s, MIN(balance) AS mn, MAX(balance) AS mx FROM t WHERE balance > spend") + .unwrap(); + let want = [ + rt.get(0, "n").unwrap().as_num().unwrap(), + rt.get(0, "s").unwrap().as_num().unwrap(), + rt.get(0, "mn").unwrap().as_num().unwrap(), + rt.get(0, "mx").unwrap().as_num().unwrap(), + ]; + // balance > spend → 行 0(100>50), 1(500>400), 3(600>200);行 2(250>300✗)、4(300>300✗) + assert_eq!(want, [3.0, 1200.0, 100.0, 600.0], "明文基准"); + + let run = |pred: Pred| -> Vec { + let (pa, pb) = Pipe::pair(); + let sites = ["alice", "bob"]; + let fxp = 18u32; + let seed = [53u8; 32]; + let mut va = Vault::new(pa, "alice", &sites, seed, fxp).unwrap(); + let mut vb = Vault::new(pb, "bob", &sites, seed, fxp).unwrap(); + let (b0, b1) = split_vec(&mut va, &balance, fxp); + let (s0, s1) = split_vec(&mut va, &spend, fxp); + let p2 = pred.clone(); + let ha = thread::spawn(move || { + secure_where_aggregate_pred(&mut va, &[b0, s0], &pred, 0, &aggs) + }); + let hb = thread::spawn(move || { + let _ = secure_where_aggregate_pred(&mut vb, &[b1, s1], &p2, 0, &aggs); + }); + let r = ha.join().unwrap().unwrap(); + hb.join().unwrap(); + r + }; + + let got = run(Pred::CmpCol { + col: 0, + op: CmpOp::Gt, + rhs_col: 1, + }); + assert_eq!(got[0], want[0], "COUNT"); + assert!((got[1] - want[1]).abs() < 1e-6, "SUM {} vs {}", got[1], want[1]); + assert_eq!(got[2], want[2], "MIN"); + assert_eq!(got[3], want[3], "MAX"); + + // 反向:spend > balance → 行 2 一行 → 1, 250 + let rt2 = e + .sql("SELECT COUNT(*) AS n, SUM(balance) AS s FROM t WHERE spend > balance") + .unwrap(); + let want2 = [ + rt2.get(0, "n").unwrap().as_num().unwrap(), + rt2.get(0, "s").unwrap().as_num().unwrap(), + ]; + assert_eq!(want2, [1.0, 250.0], "反向明文基准"); + let got2 = run(Pred::CmpCol { + col: 1, + op: CmpOp::Gt, + rhs_col: 0, + }); + assert_eq!(got2[0], want2[0], "反向 COUNT"); + assert!((got2[1] - want2[1]).abs() < 1e-6, "反向 SUM {}", got2[1]); + + // 相等:balance = spend → 行 4 一行 → 1, 300 + let rt3 = e + .sql("SELECT COUNT(*) AS n, SUM(balance) AS s FROM t WHERE balance = spend") + .unwrap(); + let want3 = [ + rt3.get(0, "n").unwrap().as_num().unwrap(), + rt3.get(0, "s").unwrap().as_num().unwrap(), + ]; + assert_eq!(want3, [1.0, 300.0], "相等明文基准"); + let got3 = run(Pred::CmpCol { + col: 0, + op: CmpOp::Eq, + rhs_col: 1, + }); + assert_eq!(got3[0], want3[0], "相等 COUNT"); + assert!((got3[1] - want3[1]).abs() < 1e-6, "相等 SUM {}", got3[1]); + } + + /// 列 vs 列 + GROUP BY:`GROUP BY g` 且 `WHERE balance > spend`。 + #[test] + fn secure_group_by_col_pred_matches_engine() { + let balance = [100.0f64, 500.0, 250.0, 600.0, 300.0]; + let spend = [50.0f64, 400.0, 300.0, 200.0, 300.0]; + let g = [0.0f64, 0.0, 1.0, 1.0, 0.0]; + let aggs = [Agg::Count, Agg::Sum]; + + let t = Table::new("t", "alice") + .with_col("balance", ColData::Num(balance.to_vec())) + .with_col("spend", ColData::Num(spend.to_vec())) + .with_col("g", ColData::Num(g.to_vec())) + .with_public("g"); + let mut e = Engine::new(0); + e.register(t); + let rt = e + .sql("SELECT g, COUNT(*) AS n, SUM(balance) AS s FROM t WHERE balance > spend GROUP BY g") + .unwrap(); + // 命中行 0(g0),1(g0),3(g1) → g0: n=2 s=600;g1: n=1 s=600 + let want: Vec<(f64, f64)> = (0..rt.nrows()) + .map(|r| { + ( + rt.get(r, "n").unwrap().as_num().unwrap(), + rt.get(r, "s").unwrap().as_num().unwrap(), + ) + }) + .collect(); + assert_eq!(want, vec![(2.0, 600.0), (1.0, 600.0)], "明文基准"); + + let (pa, pb) = Pipe::pair(); + let sites = ["alice", "bob"]; + let fxp = 18u32; + let seed = [59u8; 32]; + let mut va = Vault::new(pa, "alice", &sites, seed, fxp).unwrap(); + let mut vb = Vault::new(pb, "bob", &sites, seed, fxp).unwrap(); + let (b0, b1) = split_vec(&mut va, &balance, fxp); + let (s0, s1) = split_vec(&mut va, &spend, fxp); + let (g0, g1) = split_vec(&mut va, &g, fxp); + + let pred = Pred::CmpCol { + col: 0, + op: CmpOp::Gt, + rhs_col: 1, + }; + let p2 = pred.clone(); + let ha = thread::spawn(move || { + secure_group_by_pred(&mut va, &[b0, s0], 0, &g0, 2, Some(&pred), &aggs, 0).unwrap() + }); + let hb = thread::spawn(move || { + let _ = secure_group_by_pred(&mut vb, &[b1, s1], 0, &g1, 2, Some(&p2), &aggs, 0).unwrap(); + }); + let got = ha.join().unwrap(); + hb.join().unwrap(); + + for (i, (w, gr)) in want.iter().zip(&got).enumerate() { + assert_eq!(gr[0], w.0, "组 {i} COUNT"); + assert!((gr[1] - w.1).abs() < 1e-6, "组 {i} SUM {} vs {}", gr[1], w.1); + } + } + + /// 列与自身比较是恒真/恒假,拒收 —— 多半是调用方写错了。 + #[test] + fn secure_cmp_col_self_rejected() { + let x = [1.0f64, 2.0]; + let (pa, pb) = Pipe::pair(); + let sites = ["alice", "bob"]; + let fxp = 18u32; + let seed = [61u8; 32]; + let mut va = Vault::new(pa, "alice", &sites, seed, fxp).unwrap(); + let mut vb = Vault::new(pb, "bob", &sites, seed, fxp).unwrap(); + let (x0, x1) = split_vec(&mut va, &x, fxp); + + let pred = Pred::CmpCol { + col: 0, + op: CmpOp::Eq, + rhs_col: 0, + }; + let p2 = pred.clone(); + let ha = thread::spawn(move || secure_where_aggregate_pred(&mut va, &[x0], &pred, 0, &[Agg::Count])); + let hb = thread::spawn(move || secure_where_aggregate_pred(&mut vb, &[x1], &p2, 0, &[Agg::Count])); + let ra = ha.join().unwrap(); + let rb = hb.join().unwrap(); + assert!(ra.is_err(), "本方应拒收自身比较: {ra:?}"); + assert!(rb.is_err(), "对端应拒收自身比较: {rb:?}"); + } }