feat(sql): 复合谓词密态求值(AND/OR/NOT 组合比较)

secure 新增 Pred(Cmp/And/Or/Not) + secure_predicate_mask 递归求掩码,
secure_where_aggregate_pred 在掩码下聚合。对齐明文引擎的任意布尔表达式:
x<400 AND g=0、x<400 OR g=1、NOT x<400 三例均对拍通过。

nax-sql --features secure 20 测,workspace 217 全绿、零警告。
This commit is contained in:
rong committed 2026-10-30 16:47:16 +08:00
1 parent ee7aae6f04
commit 633d9b548b
3 files changed
+141 -3

No files matched your search

+1 -1
View File
@@ -32,7 +32,7 @@
| `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+聚合+GROUP BY 3 测 |
| `nax-sql` SCQL 引擎 | ✅ 手写解析器 + 掩码式 WHERE + 聚合/GROUP BY/k-匿名/投影约束/JOIN/HAVING/ORDER BY,15 测;`--features secure` 另有密态 WHERE/复合谓词/GROUP BY/k-匿名 5 测 |
| `nax-policy` 策略/审计 | ✅ 出域守卫(exec/transfer/fetch)+ Label 六档 + 审计日志(过滤/汇总/裁剪),9 测 |
| `nax-runtime` 执行模式 | ✅ dry_run / real_run(线程局部 + RAII 嵌套恢复),4 测 |
| `nax-he` Paillier/OLE | ✅ 无可信发牌方 Beaver 物料 + PIR,50 条 Python 逐位对照 + 13 语义测试 |
+137
View File
@@ -197,6 +197,67 @@ pub fn secure_group_by<T: Transport>(
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 },
And(Box<Pred>, Box<Pred>),
Or(Box<Pred>, Box<Pred>),
Not(Box<Pred>),
}
/// 递归求复合谓词的 0/1 掩码。
pub fn secure_predicate_mask<T: Transport>(
vault: &mut Vault<T>,
cols: &[Vec<u64>],
pred: &Pred,
) -> Result<Vec<u64>, VaultError> {
match pred {
Pred::Cmp { col, op, threshold } => {
let c = cols
.get(*col)
.ok_or_else(|| VaultError::Protocol(format!("谓词引用了不存在的列 {col}")))?;
let th = vault.constant(*threshold, c.len())?;
mask_for(vault, c, &th, *op)
}
Pred::And(a, b) => {
let ma = secure_predicate_mask(vault, cols, a)?;
let mb = secure_predicate_mask(vault, cols, b)?;
vault.bit_and(&ma, &mb)
}
Pred::Or(a, b) => {
let ma = secure_predicate_mask(vault, cols, a)?;
let mb = secure_predicate_mask(vault, cols, b)?;
vault.bit_or(&ma, &mb)
}
Pred::Not(a) => {
let m = secure_predicate_mask(vault, cols, a)?;
vault.bit_not(&m)
}
}
}
/// 密态执行带复合谓词的聚合:`SELECT <aggs(agg_col)> FROM t WHERE <pred>`。
pub fn secure_where_aggregate_pred<T: Transport>(
vault: &mut Vault<T>,
cols: &[Vec<u64>],
pred: &Pred,
agg_col: usize,
aggs: &[Agg],
) -> Result<Vec<f64>, VaultError> {
let agg = cols
.get(agg_col)
.ok_or_else(|| VaultError::Protocol(format!("聚合列 {agg_col} 不存在")))?;
let mask = secure_predicate_mask(vault, cols, pred)?;
if mask.len() != agg.len() {
return Err(VaultError::Protocol("掩码与聚合列长度不一致".into()));
}
let (_count, vals) = aggregate_with_mask(vault, agg, &mask, aggs)?;
Ok(vals)
}
#[cfg(test)]
mod tests {
use super::*;
@@ -337,6 +398,82 @@ mod tests {
}
}
/// 复合谓词(AND / OR / NOT)密态求值,对拍明文引擎。
#[test]
fn secure_compound_predicate_matches_engine() {
let x = [100.0f64, 500.0, 250.0, 600.0, 300.0];
let g = [0.0f64, 1.0, 0.0, 1.0, 0.0];
let aggs = [Agg::Count, Agg::Sum];
let t = Table::new("t", "alice")
.with_col("x", ColData::Num(x.to_vec()))
.with_col("g", ColData::Num(g.to_vec()));
let mut e = Engine::new(0);
e.register(t);
let cmp = |sql: &str| -> (f64, f64) {
let rt = e.sql(sql).unwrap();
(
rt.get(0, "n").unwrap().as_num().unwrap(),
rt.get(0, "s").unwrap().as_num().unwrap(),
)
};
let run = |pred: Pred| -> Vec<f64> {
let (pa, pb) = Pipe::pair();
let sites = ["alice", "bob"];
let fxp = 18u32;
let seed = [43u8; 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 (g0, g1) = split_vec(&mut va, &g, fxp);
let p2 = pred.clone();
let ha = thread::spawn(move || {
secure_where_aggregate_pred(&mut va, &[x0, g0], &pred, 0, &aggs)
});
let hb = thread::spawn(move || {
let _ = secure_where_aggregate_pred(&mut vb, &[x1, g1], &p2, 0, &aggs);
});
let r = ha.join().unwrap().unwrap();
hb.join().unwrap();
r
};
// AND: x < 400 AND g = 0 → 行 0,2,4 → 3, 650
let p_and = Pred::And(
Box::new(Pred::Cmp { col: 0, op: CmpOp::Lt, threshold: 400.0 }),
Box::new(Pred::Cmp { col: 1, op: CmpOp::Eq, threshold: 0.0 }),
);
let want = cmp("SELECT COUNT(*) AS n, SUM(x) AS s FROM t WHERE x < 400 AND g = 0");
assert_eq!(want, (3.0, 650.0));
let got = run(p_and);
assert_eq!(got[0], want.0, "AND COUNT");
assert!((got[1] - want.1).abs() < 1e-6, "AND SUM {}", got[1]);
// OR: x < 400 OR g = 1 → 全部 5 行 → 5, 1750
let p_or = Pred::Or(
Box::new(Pred::Cmp { col: 0, op: CmpOp::Lt, threshold: 400.0 }),
Box::new(Pred::Cmp { col: 1, op: CmpOp::Eq, threshold: 1.0 }),
);
let want = cmp("SELECT COUNT(*) AS n, SUM(x) AS s FROM t WHERE x < 400 OR g = 1");
assert_eq!(want, (5.0, 1750.0));
let got = run(p_or);
assert_eq!(got[0], want.0, "OR COUNT");
assert!((got[1] - want.1).abs() < 1e-6, "OR SUM {}", got[1]);
// NOT: NOT (x < 400) → x >= 400 → 行 1,3 → 2, 1100
let p_not = Pred::Not(Box::new(Pred::Cmp {
col: 0,
op: CmpOp::Lt,
threshold: 400.0,
}));
let want = cmp("SELECT COUNT(*) AS n, SUM(x) AS s FROM t WHERE NOT x < 400");
assert_eq!(want, (2.0, 1100.0));
let got = run(p_not);
assert_eq!(got[0], want.0, "NOT COUNT");
assert!((got[1] - want.1).abs() < 1e-6, "NOT SUM {}", got[1]);
}
/// k-匿名:命中数低于阈值的分组整行置 NaN。
#[test]
fn secure_group_by_k_anonymity() {
+3 -2
View File
@@ -93,8 +93,9 @@ Python 参考版 `nax/` 共 **8,963 行**。此前约 **4,150 行(≈46%)未
- **`nax-sql` 加可选 `secure` feature**:`secure::secure_where_aggregate` 实现
`SELECT <COUNT/SUM/AVG/MIN/MAX> FROM t WHERE col <op> T`:掩码 = `bit_lt/gt/eq` → `bit_mask` → 本地线性求和/`scale_public`+`truncate`;MIN/MAX 用 `(1−mask)·(±SENTINEL)` 本地补位后两两 `bit_lt`+`select_raw` 归约。
`secure::secure_group_by`:逐**公开码** c 做 `bit_eq(gcol, c)` 与 WHERE 掩码 AND,再走同一聚合核心。阈值/组码用 `nax-vault::constant`(公开常量分片 `(c,0,…)`),无需调用方 split。3 测对拍明文 `Engine`(WHERE+聚合、空命中 NaN、GROUP BY)。
`secure::secure_group_by`:逐**公开码** c 做 `bit_eq(gcol, c)` 与 WHERE 掩码 AND,再走同一聚合核心。阈值/组码用 `nax-vault::constant`(公开常量分片 `(c,0,…)`),无需调用方 split。
`secure::secure_predicate_mask` + `Pred`:复合谓词(AND/OR/NOT 组合比较)走 `bit_and/or/not`,对齐引擎的任意布尔表达式。5 测对拍明文 `Engine`(WHERE+聚合、空命中 NaN、GROUP BY、k-匿名、复合谓词 AND/OR/NOT)。
- **`nax-ml::binning_secure`**:`secure_bin_counts` 实现 `bad = Mᵀ·y`(`matmul_trunc`,转置为本地置换)+ `total`(本地列和)。1 测对拍明文 `Mᵀ@y` / `Mᵀ@1`。`nax-ml` 已硬依赖 `nax-vault`,无需 feature。
- 尺度约定:one-hot 与标签都按 fxp 编码(`1 → 2^fxp`),`Mᵀ@y` 落在 `2·fxp`,`matmul_trunc` 截回 `fxp`;`total` 线性列和天然 `fxp`。
- **CLI 端到端演示**:`nax sql`(编译需 `--features secure`)在单进程内用两条 `Pipe` 起 2 方,真跑一遍 `GROUP BY + COUNT/SUM/AVG`,打印结果表——从二进制直接看到密态 SQL 生效。
- 现状:`cargo test --workspace` 217 测;`-p nax-sql --features secure` 19 测、`-p nax-fl --features secure` 13 测、`-p nax-ml` 15 测,全绿、零警告。
- 现状:`cargo test --workspace` 217 测;`-p nax-sql --features secure` 20 测、`-p nax-fl --features secure` 13 测、`-p nax-ml` 15 测,全绿、零警告。