feat(sql): 密态 WHERE 支持列 vs 列

影响:`WHERE balance > spend` 这类跨列谓词现在能密态求值;
右值是密文分片不过 `vault.constant`(不泄露阈值),开销与列 vs 常量相同。

- `Pred::CmpCol { col, op, rhs_col }`:列与列比较,`mask_for` 两侧本就吃分片。
- `secure_group_by_pred`:吃任意 Pred(含 CmpCol)的 GROUP BY 入口,
  下标约定与 `secure_where_aggregate_pred` 一致;旧 `secure_group_by` 不动。
- 列与自身比较拒收(`x > x` 恒假,多半是写错了)。
- 新增 3 测含变异检验:右值偷换成公开常量 0 → 2 条红。
This commit is contained in:
rong committed 2026-10-30 18:32:17 +08:00
1 parent 355d1be699
commit b3baeb8690
1 file changed
+264
+264
View File
@@ -197,12 +197,74 @@ pub fn secure_group_by<T: Transport>(
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<T: Transport>(
vault: &mut Vault<T>,
cols: &[Vec<u64>],
agg_col: usize,
gcol: &[u64],
n_groups: usize,
pred: Option<&Pred>,
aggs: &[Agg],
min_group_size: usize,
) -> Result<Vec<Vec<f64>>, 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 <op> 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<f64>, negated: bool },
And(Box<Pred>, Box<Pred>),
@@ -224,6 +286,29 @@ pub fn secure_predicate_mask<T: Transport>(
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<f64> {
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:?}");
}
}