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:
1 parent
355d1be699
commit
b3baeb8690
1 file changed
+264
@@ -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:?}");
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user