ci / gate (push) Waiting to run
- 项目与文档标题:nax-rs → ssw-mpc(尚数网-多方安全计算),二进制 nax → mpc - 18 个 crate 及目录 nax-* → mpc-*,Rust 引用 nax_* → mpc_* - 环境变量、C 符号、构建/部署脚本:NAX_* → MPC_*、libnax_ray.so → libmpc_ray.so - 保留协议域分隔常量与 refs/nax 参考实现路径,维持 golden 向量与历史数据兼容 - 新增 [profile.dev] incremental=false
727 lines
25 KiB
Rust
727 lines
25 KiB
Rust
//! 迁移回归:把手写协议序列留在测试里当 **oracle**,与图版本对话。
|
||
//!
|
||
//! # 为什么需要这个文件
|
||
//!
|
||
//! `secure.rs` 原有的验收是「与明文引擎对拍」。那条断言对**搬家**不够 ——
|
||
//! 把 `bit_not` 挪到 `scale_public` 之前、把掩码补位漏一次,很多组合下结果
|
||
//! 照样对得上(比如命中全满或全空时补位项恒为 0)。
|
||
//!
|
||
//! 这里把迁移前的实现原样抄下来(`legacy_*`),从两个角度比对:
|
||
//!
|
||
//! 1. **数值**:`COUNT` / `SUM` / `MIN` / `MAX` 必须**逐位相同**,`AVG` 落在
|
||
//! 舍入预算内(原因见下)。
|
||
//! 2. **轮数**:图版本不能比手写版本多花往返 —— 搬家的目的是让轮数可报,
|
||
//! 不是顺手让性能变差。
|
||
//!
|
||
//! # 为什么 `AVG` 不是逐位相同
|
||
//!
|
||
//! `AVG` 是唯一走过 `truncate` 的聚合,而 `mpc-vault::truncate` 是**随机舍入**:
|
||
//!
|
||
//! ```text
|
||
//! c = x + r (r 是离线发的截断对,全环均匀)
|
||
//! cs = c >> fxp (算术右移)
|
||
//! out = cs − (r >> fxp)
|
||
//! ```
|
||
//!
|
||
//! 两条路径调用 dealer 取随机数的**次数**不同(Beaver 三元组的消耗方式不一样),
|
||
//! 所以拿到的那份 `r` 不同,结果差 ±1 ULP。`mpc-ml` 的迁移回归踩过同样的坑,
|
||
//! 判据也一致:协议形状对得上 + 数值在舍入预算内,而不是「逐位相同」。
|
||
//!
|
||
//! `COUNT`(原始整数)、`SUM`(本地列和)、`MIN`/`MAX`(比较 + 选择,全程精确)
|
||
//! 都不经过截断,所以那四个必须是逐位相同。
|
||
|
||
use mpc_core::ring;
|
||
use mpc_proto::Frame;
|
||
use mpc_sql::secure::{
|
||
query_rounds, secure_aggregate_all, secure_group_by, secure_predicate_mask,
|
||
secure_where_aggregate, Agg, CmpOp, GroupMode, Pred,
|
||
};
|
||
use mpc_vault::{Pipe, Transport, Vault, VaultError};
|
||
use std::sync::{Arc, Mutex};
|
||
|
||
const FXP: u32 = 18;
|
||
|
||
fn enc(v: &[f64]) -> Vec<u64> {
|
||
v.iter().map(|x| ring::encode(*x, FXP).unwrap()).collect()
|
||
}
|
||
|
||
// --------------------------------------------------------------------------- //
|
||
// 迁移前的实现(逐字保留,只用来当 oracle)
|
||
// --------------------------------------------------------------------------- //
|
||
|
||
const LEGACY_SENTINEL: f64 = (1u64 << 30) as f64;
|
||
|
||
fn legacy_mask_for<T: Transport>(
|
||
vault: &mut Vault<T>,
|
||
col: &[u64],
|
||
thresh: &[u64],
|
||
op: CmpOp,
|
||
) -> Result<Vec<u64>, VaultError> {
|
||
match op {
|
||
CmpOp::Lt => vault.bit_lt(col, thresh),
|
||
CmpOp::Gt => vault.bit_gt(col, thresh),
|
||
CmpOp::Eq => vault.bit_eq(col, thresh),
|
||
CmpOp::Le => {
|
||
let gt = vault.bit_gt(col, thresh)?;
|
||
vault.bit_not(>)
|
||
}
|
||
CmpOp::Ge => {
|
||
let lt = vault.bit_lt(col, thresh)?;
|
||
vault.bit_not(<)
|
||
}
|
||
CmpOp::Ne => {
|
||
let eq = vault.bit_eq(col, thresh)?;
|
||
vault.bit_not(&eq)
|
||
}
|
||
}
|
||
}
|
||
|
||
fn legacy_aggregate_with_mask<T: Transport>(
|
||
vault: &mut Vault<T>,
|
||
col: &[u64],
|
||
mask: &[u64],
|
||
aggs: &[Agg],
|
||
) -> Result<(usize, Vec<f64>), VaultError> {
|
||
let fxp = vault.fxp();
|
||
let len = col.len();
|
||
let masked = vault.bit_mask(mask, col)?;
|
||
|
||
let mut count_sh = 0u64;
|
||
for &m in mask {
|
||
count_sh = count_sh.wrapping_add(m);
|
||
}
|
||
let count = vault.reveal(&[count_sh])?[0] as usize;
|
||
|
||
let mut out = Vec::with_capacity(aggs.len());
|
||
for &agg in aggs {
|
||
let v = match agg {
|
||
Agg::Count => count as f64,
|
||
Agg::Sum => {
|
||
let mut s = 0u64;
|
||
for &v in &masked {
|
||
s = s.wrapping_add(v);
|
||
}
|
||
ring::decode(vault.reveal(&[s])?[0], fxp)
|
||
}
|
||
Agg::Avg => {
|
||
if count == 0 {
|
||
f64::NAN
|
||
} else {
|
||
let mut s = 0u64;
|
||
for &v in &masked {
|
||
s = s.wrapping_add(v);
|
||
}
|
||
let scaled = vault.scale_public(&[s], 1.0 / count as f64)?;
|
||
let tr = vault.truncate(&scaled)?;
|
||
ring::decode(vault.reveal(&tr)?[0], fxp)
|
||
}
|
||
}
|
||
Agg::Min | Agg::Max => {
|
||
if count == 0 {
|
||
f64::NAN
|
||
} else {
|
||
let one_minus = vault.bit_not(mask)?;
|
||
let pad_sign = if agg == Agg::Min {
|
||
LEGACY_SENTINEL
|
||
} else {
|
||
-LEGACY_SENTINEL
|
||
};
|
||
let pad = vault.scale_public(&one_minus, pad_sign)?;
|
||
let padded = vault.add_local(&masked, &pad)?;
|
||
let mut best = padded[0..1].to_vec();
|
||
for i in 1..len {
|
||
let cur = padded[i..i + 1].to_vec();
|
||
let pick_cur = if agg == Agg::Min {
|
||
vault.bit_lt(&cur, &best)?
|
||
} else {
|
||
vault.bit_lt(&best, &cur)?
|
||
};
|
||
best = vault.select_raw(&pick_cur, &cur, &best)?;
|
||
}
|
||
ring::decode(vault.reveal(&best)?[0], fxp)
|
||
}
|
||
}
|
||
};
|
||
out.push(v);
|
||
}
|
||
Ok((count, out))
|
||
}
|
||
|
||
fn legacy_where_aggregate<T: Transport>(
|
||
vault: &mut Vault<T>,
|
||
col: &[u64],
|
||
threshold: f64,
|
||
op: CmpOp,
|
||
aggs: &[Agg],
|
||
) -> Result<Vec<f64>, VaultError> {
|
||
let th = vault.constant(threshold, col.len())?;
|
||
let mask = legacy_mask_for(vault, col, &th, op)?;
|
||
let (_count, vals) = legacy_aggregate_with_mask(vault, col, &mask, aggs)?;
|
||
Ok(vals)
|
||
}
|
||
|
||
fn legacy_group_by<T: Transport>(
|
||
vault: &mut Vault<T>,
|
||
col: &[u64],
|
||
gcol: &[u64],
|
||
n_groups: usize,
|
||
pred: Option<(f64, CmpOp)>,
|
||
aggs: &[Agg],
|
||
min_group_size: usize,
|
||
) -> Result<Vec<Vec<f64>>, VaultError> {
|
||
let len = col.len();
|
||
let base = match pred {
|
||
Some((t, op)) => {
|
||
let th = vault.constant(t, len)?;
|
||
legacy_mask_for(vault, col, &th, op)?
|
||
}
|
||
None => vault.bit_one(len),
|
||
};
|
||
|
||
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) = legacy_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)
|
||
}
|
||
|
||
fn legacy_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[*col];
|
||
let th = vault.constant(*threshold, c.len())?;
|
||
legacy_mask_for(vault, c, &th, *op)
|
||
}
|
||
Pred::CmpCol { col, op, rhs_col } => {
|
||
legacy_mask_for(vault, &cols[*col], &cols[*rhs_col], *op)
|
||
}
|
||
Pred::In {
|
||
col,
|
||
values,
|
||
negated,
|
||
} => {
|
||
let c = &cols[*col];
|
||
let mut mask: Option<Vec<u64>> = None;
|
||
for &v in values {
|
||
let th = vault.constant(v, c.len())?;
|
||
let eq = vault.bit_eq(c, &th)?;
|
||
mask = Some(match mask {
|
||
None => eq,
|
||
Some(prev) => vault.bit_or(&prev, &eq)?,
|
||
});
|
||
}
|
||
let m = mask.unwrap();
|
||
if *negated {
|
||
vault.bit_not(&m)
|
||
} else {
|
||
Ok(m)
|
||
}
|
||
}
|
||
Pred::And(a, b) => {
|
||
let ma = legacy_predicate_mask(vault, cols, a)?;
|
||
let mb = legacy_predicate_mask(vault, cols, b)?;
|
||
vault.bit_and(&ma, &mb)
|
||
}
|
||
Pred::Or(a, b) => {
|
||
let ma = legacy_predicate_mask(vault, cols, a)?;
|
||
let mb = legacy_predicate_mask(vault, cols, b)?;
|
||
vault.bit_or(&ma, &mb)
|
||
}
|
||
Pred::Not(a) => {
|
||
let m = legacy_predicate_mask(vault, cols, a)?;
|
||
vault.bit_not(&m)
|
||
}
|
||
}
|
||
}
|
||
|
||
// --------------------------------------------------------------------------- //
|
||
// 脚手架
|
||
// --------------------------------------------------------------------------- //
|
||
|
||
/// 记收/发序列的传输层。
|
||
struct Recorder<T> {
|
||
inner: T,
|
||
log: Arc<Mutex<String>>,
|
||
}
|
||
|
||
impl<T: Transport> Transport for Recorder<T> {
|
||
fn send_to(&mut self, party: usize, frame: Frame) -> Result<(), VaultError> {
|
||
self.log.lock().unwrap().push('S');
|
||
self.inner.send_to(party, frame)
|
||
}
|
||
|
||
fn recv_from(&mut self, party: usize) -> Result<Frame, VaultError> {
|
||
self.log.lock().unwrap().push('R');
|
||
self.inner.recv_from(party)
|
||
}
|
||
}
|
||
|
||
/// 数往返:连续的 `S` 算一轮,「收到之后又发」才开新的一轮。
|
||
///
|
||
/// 数突发不数帧 —— 一次 `open_batch` 发两帧收两帧仍是一个往返。
|
||
fn count_rounds(log: &str) -> usize {
|
||
let (mut rounds, mut seen_send, mut seen_recv) = (0usize, false, false);
|
||
for c in log.chars() {
|
||
match c {
|
||
'S' => {
|
||
if seen_recv {
|
||
rounds += 1;
|
||
seen_recv = false;
|
||
}
|
||
if !seen_send {
|
||
seen_send = true;
|
||
rounds += 1;
|
||
}
|
||
}
|
||
'R' => seen_recv = true,
|
||
_ => {}
|
||
}
|
||
}
|
||
rounds
|
||
}
|
||
|
||
/// 把一份明文分好片,两方各持一片(用一个临时 Vault 做发牌)。
|
||
fn split(vals: &[f64]) -> (Vec<u64>, Vec<u64>) {
|
||
let mut v = Vault::new(Pipe::pair().0, "alice", &["alice", "bob"], [5u8; 32], FXP).unwrap();
|
||
let all = v.split(&enc(vals)).unwrap();
|
||
let len = vals.len();
|
||
(all[0..len].to_vec(), all[len..2 * len].to_vec())
|
||
}
|
||
|
||
/// 两方跑同一段查询,返回(alice 侧结果, alice 侧收/发序列)。
|
||
///
|
||
/// **先取日志再返回**:查询函数自己内部的 `reveal` 算在它自己的往返里,
|
||
/// 这里不做额外确认。
|
||
fn run_two<FA, FB, R>(pairs: Vec<(Vec<u64>, Vec<u64>)>, alice: FA, bob: FB) -> (R, usize)
|
||
where
|
||
FA: FnOnce(&mut Vault<Recorder<Pipe>>, Vec<Vec<u64>>) -> Result<R, VaultError> + Send + 'static,
|
||
FB: FnOnce(&mut Vault<Pipe>, Vec<Vec<u64>>) -> Result<R, VaultError> + Send + 'static,
|
||
R: Send + 'static,
|
||
{
|
||
let sites = ["alice", "bob"];
|
||
let seed = [11u8; 32];
|
||
let log = Arc::new(Mutex::new(String::new()));
|
||
let (pa, pb) = Pipe::pair();
|
||
let mut va = Vault::new(
|
||
Recorder {
|
||
inner: pa,
|
||
log: log.clone(),
|
||
},
|
||
"alice",
|
||
&sites,
|
||
seed,
|
||
FXP,
|
||
)
|
||
.unwrap();
|
||
let mut vb = Vault::new(pb, "bob", &sites, seed, FXP).unwrap();
|
||
|
||
let a_side: Vec<Vec<u64>> = pairs.iter().map(|(a, _)| a.clone()).collect();
|
||
let b_side: Vec<Vec<u64>> = pairs.iter().map(|(_, b)| b.clone()).collect();
|
||
|
||
let h = std::thread::spawn(move || bob(&mut vb, b_side));
|
||
let out = alice(&mut va, a_side).unwrap();
|
||
h.join().unwrap().unwrap();
|
||
|
||
let rounds = count_rounds(&log.lock().unwrap().clone());
|
||
(out, rounds)
|
||
}
|
||
|
||
fn shares_of(cols: &[&[f64]]) -> Vec<(Vec<u64>, Vec<u64>)> {
|
||
cols.iter().map(|c| split(c)).collect()
|
||
}
|
||
|
||
/// `AVG` 的容差。截断是 ±1 ULP 的随机舍入,五个元素凑一起也就几 ULP。
|
||
const AVG_TOL: f64 = 1e-4;
|
||
|
||
// --------------------------------------------------------------------------- //
|
||
// 1. WHERE + 聚合:逐位相同
|
||
// --------------------------------------------------------------------------- //
|
||
|
||
fn amounts() -> Vec<f64> {
|
||
vec![100.0, 500.0, 250.0, 600.0, 300.0]
|
||
}
|
||
|
||
const ALL_AGGS: [Agg; 5] = [Agg::Count, Agg::Sum, Agg::Avg, Agg::Min, Agg::Max];
|
||
|
||
#[test]
|
||
fn where_aggregate_matches_legacy_for_every_cmp_op() {
|
||
let data = amounts(); for op in [
|
||
CmpOp::Lt,
|
||
CmpOp::Le,
|
||
CmpOp::Gt,
|
||
CmpOp::Ge,
|
||
CmpOp::Eq,
|
||
CmpOp::Ne,
|
||
] {
|
||
let (want, legacy_rounds) = {
|
||
let sh = shares_of(&[&data]);
|
||
run_two(
|
||
sh,
|
||
move |v, s| legacy_where_aggregate(v, &s[0], 300.0, op, &ALL_AGGS),
|
||
move |v, s| legacy_where_aggregate(v, &s[0], 300.0, op, &ALL_AGGS),
|
||
)
|
||
};
|
||
let (got, graph_rounds) = {
|
||
let sh = shares_of(&[&data]);
|
||
run_two(
|
||
sh,
|
||
move |v, s| secure_where_aggregate(v, &s[0], 300.0, op, &ALL_AGGS),
|
||
move |v, s| secure_where_aggregate(v, &s[0], 300.0, op, &ALL_AGGS),
|
||
)
|
||
};
|
||
|
||
println!("where {op:?}: 迁移前 {legacy_rounds} 轮 → 迁移后 {graph_rounds} 轮");
|
||
assert_eq!(got[0], want[0], "{op:?} COUNT 必须逐位相同");
|
||
assert_eq!(got[1], want[1], "{op:?} SUM 必须逐位相同");
|
||
assert_eq!(got[3], want[3], "{op:?} MIN 必须逐位相同");
|
||
assert_eq!(got[4], want[4], "{op:?} MAX 必须逐位相同");
|
||
assert!(
|
||
(got[2] - want[2]).abs() < AVG_TOL,
|
||
"{op:?} AVG {} vs {},超出舍入预算",
|
||
got[2],
|
||
want[2]
|
||
);
|
||
assert!(
|
||
graph_rounds <= legacy_rounds,
|
||
"{op:?} 图版本花了 {graph_rounds} 轮,手写版只有 {legacy_rounds} 轮 —— 搬家不该更慢"
|
||
);
|
||
}
|
||
}
|
||
|
||
/// 空选择的语义:`SUM` 是 0,`AVG`/`MIN`/`MAX` 是 `NaN`。逐位对齐。
|
||
#[test]
|
||
fn empty_selection_matches_legacy() {
|
||
let data = amounts();
|
||
let (want, _) = {
|
||
let sh = shares_of(&[&data]);
|
||
run_two(
|
||
sh,
|
||
|v, s| legacy_where_aggregate(v, &s[0], 5.0, CmpOp::Lt, &ALL_AGGS),
|
||
|v, s| legacy_where_aggregate(v, &s[0], 5.0, CmpOp::Lt, &ALL_AGGS),
|
||
)
|
||
};
|
||
let (got, _) = {
|
||
let sh = shares_of(&[&data]);
|
||
run_two(
|
||
sh,
|
||
|v, s| secure_where_aggregate(v, &s[0], 5.0, CmpOp::Lt, &ALL_AGGS),
|
||
|v, s| secure_where_aggregate(v, &s[0], 5.0, CmpOp::Lt, &ALL_AGGS),
|
||
)
|
||
};
|
||
assert_eq!(got[0], 0.0, "COUNT");
|
||
assert_eq!(got[1], 0.0, "SUM 在空选择下是 0,不是 NaN");
|
||
assert!(got[2].is_nan(), "AVG");
|
||
assert!(got[3].is_nan(), "MIN");
|
||
assert!(got[4].is_nan(), "MAX");
|
||
assert_eq!(got[0], want[0]);
|
||
assert_eq!(got[1], want[1]);
|
||
assert_eq!(got[2].is_nan(), want[2].is_nan());
|
||
}
|
||
|
||
// --------------------------------------------------------------------------- //
|
||
// 2. GROUP BY:逐位相同,且轮数不增
|
||
// --------------------------------------------------------------------------- //
|
||
|
||
fn region_data() -> (Vec<f64>, Vec<f64>) {
|
||
(
|
||
vec![100.0, 500.0, 250.0, 600.0, 300.0, 450.0],
|
||
vec![0.0, 1.0, 0.0, 1.0, 0.0, 1.0],
|
||
)
|
||
}
|
||
|
||
#[test]
|
||
fn group_by_matches_legacy() {
|
||
let (x, g) = region_data();
|
||
let aggs = [Agg::Count, Agg::Sum];
|
||
// 组数也要扫:掩码是「基础掩码 AND 组码相等」,组数改变的是**分支个数**,
|
||
// 而分支个数正是「各组的 open 能不能合成一轮」的前提。2 组的用例看不出
|
||
// 合并,4 组才看得出(组 2/3 是空组,顺带覆盖命中数为 0 的分支)。
|
||
for n_groups in [2usize, 4, 8] {
|
||
for pred in [None, Some((400.0, CmpOp::Lt))] {
|
||
for min_size in [0usize, 2] {
|
||
let (want, legacy_rounds) = {
|
||
let sh = shares_of(&[&x, &g]);
|
||
run_two(
|
||
sh,
|
||
move |v, s| {
|
||
legacy_group_by(v, &s[0], &s[1], n_groups, pred, &aggs, min_size)
|
||
},
|
||
move |v, s| {
|
||
legacy_group_by(v, &s[0], &s[1], n_groups, pred, &aggs, min_size)
|
||
},
|
||
)
|
||
};
|
||
let (got, graph_rounds) = {
|
||
let sh = shares_of(&[&x, &g]);
|
||
run_two(
|
||
sh,
|
||
move |v, s| {
|
||
secure_group_by(v, &s[0], &s[1], n_groups, pred, &aggs, min_size)
|
||
},
|
||
move |v, s| {
|
||
secure_group_by(v, &s[0], &s[1], n_groups, pred, &aggs, min_size)
|
||
},
|
||
)
|
||
};
|
||
assert_eq!(got.len(), n_groups, "组数");
|
||
println!(
|
||
"group_by 组数={n_groups} pred={pred:?} min={min_size}: 迁移前 {legacy_rounds} 轮 → 迁移后 {graph_rounds} 轮"
|
||
);
|
||
for i in 0..got.len() {
|
||
// k-匿名抑制的两边都是 NaN,而 `NaN != NaN` —— 先比 NaN-ness,
|
||
// 再比值本身,否则「两边都抑制了」会被判成失败。
|
||
for (k, name) in [(0usize, "COUNT"), (1usize, "SUM")] {
|
||
assert_eq!(
|
||
got[i][k].is_nan(),
|
||
want[i][k].is_nan(),
|
||
"组 {i} {name} 的抑制状态不一致({n_groups} 组 pred={pred:?} min={min_size})"
|
||
);
|
||
if !want[i][k].is_nan() {
|
||
assert_eq!(
|
||
got[i][k], want[i][k],
|
||
"组 {i} {name}({n_groups} 组 pred={pred:?})"
|
||
);
|
||
}
|
||
}
|
||
}
|
||
assert!(
|
||
graph_rounds <= legacy_rounds,
|
||
"{n_groups} 组 pred={pred:?} min={min_size}:图 {graph_rounds} 轮 > 手写 {legacy_rounds} 轮"
|
||
);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// --------------------------------------------------------------------------- //
|
||
// 3. 复合谓词掩码:逐位相同
|
||
// --------------------------------------------------------------------------- //
|
||
|
||
#[test]
|
||
fn predicate_mask_matches_legacy() {
|
||
let x = amounts();
|
||
let g = vec![0.0f64, 1.0, 0.0, 1.0, 0.0];
|
||
let preds = [
|
||
Pred::Cmp {
|
||
col: 0,
|
||
op: CmpOp::Lt,
|
||
threshold: 400.0,
|
||
},
|
||
Pred::CmpCol {
|
||
col: 0,
|
||
op: CmpOp::Gt,
|
||
rhs_col: 1,
|
||
},
|
||
Pred::In {
|
||
col: 0,
|
||
values: vec![100.0, 250.0],
|
||
negated: false,
|
||
},
|
||
Pred::In {
|
||
col: 0,
|
||
values: vec![100.0, 250.0],
|
||
negated: true,
|
||
},
|
||
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,
|
||
}),
|
||
),
|
||
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,
|
||
}),
|
||
),
|
||
Pred::Not(Box::new(Pred::Cmp {
|
||
col: 0,
|
||
op: CmpOp::Lt,
|
||
threshold: 400.0,
|
||
})),
|
||
];
|
||
|
||
for pred in preds {
|
||
// 四个闭包各要一份:两个给 legacy,两个给图版本。
|
||
let (p1, p2) = (pred.clone(), pred.clone());
|
||
let (p3, p4) = (pred.clone(), pred.clone());
|
||
let (want, _) = {
|
||
let sh = shares_of(&[&x, &g]);
|
||
run_two(
|
||
sh,
|
||
move |v, s| {
|
||
let m = legacy_predicate_mask(v, &s, &p1)?;
|
||
v.reveal(&m)
|
||
},
|
||
move |v, s| {
|
||
let m = legacy_predicate_mask(v, &s, &p2)?;
|
||
v.reveal(&m)
|
||
},
|
||
)
|
||
};
|
||
let (got, _) = {
|
||
let sh = shares_of(&[&x, &g]);
|
||
run_two(
|
||
sh,
|
||
move |v, s| {
|
||
let m = secure_predicate_mask(v, &s, &p3)?;
|
||
v.reveal(&m)
|
||
},
|
||
move |v, s| {
|
||
let m = secure_predicate_mask(v, &s, &p4)?;
|
||
v.reveal(&m)
|
||
},
|
||
)
|
||
};
|
||
assert_eq!(got, want, "掩码必须逐位相同(0/1 位是精确的,没有舍入余地)");
|
||
}
|
||
}
|
||
|
||
// --------------------------------------------------------------------------- //
|
||
// 4. 轮数:编译期报出来的数必须等于真跑出来的突发数
|
||
// --------------------------------------------------------------------------- //
|
||
|
||
/// `query_rounds` 是「建图不执行」报出来的上界。这里真跑一遍,数突发次数。
|
||
///
|
||
/// 两者必须**相等**:轮数模型对这个形状是精确的(同阶段 `open` 合一次、
|
||
/// 重交互算子各算各的),没有「保守多算」的余地。
|
||
#[test]
|
||
fn query_rounds_matches_the_measured_protocol() {
|
||
let data = amounts();
|
||
let pred = Pred::Cmp {
|
||
col: 0,
|
||
op: CmpOp::Lt,
|
||
threshold: 400.0,
|
||
};
|
||
// 命中 3 个(100/250/300),与 `query_rounds` 里的假设一致
|
||
let planned = query_rounds(data.len(), FXP, 1, Some(&pred), None, &ALL_AGGS, GroupMode::Exact).unwrap();
|
||
|
||
let (_, measured) = {
|
||
let sh = shares_of(&[&data]);
|
||
run_two(
|
||
sh,
|
||
move |v, s| secure_where_aggregate(v, &s[0], 400.0, CmpOp::Lt, &ALL_AGGS),
|
||
move |v, s| secure_where_aggregate(v, &s[0], 400.0, CmpOp::Lt, &ALL_AGGS),
|
||
)
|
||
};
|
||
|
||
assert_eq!(
|
||
planned.rounds(),
|
||
measured,
|
||
"计划说 {} 轮,真跑 {} 轮\n{}",
|
||
planned.rounds(),
|
||
measured,
|
||
planned.summary()
|
||
);
|
||
}
|
||
|
||
/// **组数完全不影响轮数**:各组的东西落在同一个阶段,逐类各合成一批。
|
||
///
|
||
/// 这条测试两度反转,记下来:迁移到 IR 之后是「每组 +20 轮」(每组的 `bit_eq`
|
||
/// 是两次串行比较),现在比较也批量了(`sec_cmp_batch` → `bit_lt_batch`,
|
||
/// 9 轮封顶),于是 4 组和 1 组**一样多**。
|
||
///
|
||
/// 这也解释了为什么 `GroupMode::IntegerCode` 在批量之前能把 8 组从 162 压到 92:
|
||
/// 它省的是「串行比较的个数」。比较一旦批量,那笔账就没了 —— 现在 13 → 12。
|
||
#[test]
|
||
fn group_count_no_longer_costs_rounds() {
|
||
let agg = [Agg::Count];
|
||
let one = query_rounds(8, FXP, 1, None, Some(1), &agg, GroupMode::Exact).unwrap();
|
||
let four = query_rounds(8, FXP, 1, None, Some(4), &agg, GroupMode::Exact).unwrap();
|
||
assert_eq!(
|
||
four.rounds(),
|
||
one.rounds(),
|
||
"4 组与 1 组的轮数应当相同(同类批量),实际 {} vs {}\n{}",
|
||
four.rounds(),
|
||
one.rounds(),
|
||
four.summary()
|
||
);
|
||
}
|
||
|
||
/// **树形归约的轮数随行数对数增长**,不是线性。
|
||
///
|
||
/// 第一版照抄手写循环(线性扫描),注释里写「树形不省轮数,因为串行依赖不变」——
|
||
/// 错的:依赖的**深度**从 `n−1` 变成 `⌈log₂n⌉`,而且同一层的比较互不依赖,
|
||
/// 会合成一批(9 轮封顶)。所以这里要钉住的是「行数翻倍只多一层」。
|
||
///
|
||
/// 一层 = 9 轮比较 + 1 轮选择 = 10 轮。
|
||
#[test]
|
||
fn minmax_reduction_costs_logarithmic_rounds() {
|
||
let aggs = [Agg::Min, Agg::Max];
|
||
let mut prev: Option<usize> = None;
|
||
let mut last = 0usize;
|
||
for n in [4usize, 8, 16, 32, 64, 128, 256] {
|
||
let r = query_rounds(n, FXP, 1, None, None, &aggs, GroupMode::Exact)
|
||
.unwrap()
|
||
.rounds();
|
||
if let Some(p) = prev {
|
||
assert_eq!(
|
||
r - p,
|
||
10,
|
||
"行数翻倍只该多一层(9 轮比较 + 1 轮选择),实际 {p} → {r}(n={n})"
|
||
);
|
||
}
|
||
prev = Some(r);
|
||
last = r;
|
||
}
|
||
// 256 行 83 轮。线性扫描要 255 × 10 = 2550 轮,差 30 倍 —— 这条断言就是
|
||
// 防着有人把它改回线性链。
|
||
assert_eq!(last, 83, "256 行的轮数变了,实际 {last}");
|
||
assert!(
|
||
last < 255 * 10 / 10,
|
||
"256 行 {last} 轮,已经不像对数了(线性约 2550 轮)"
|
||
);
|
||
}
|
||
|
||
/// 树形归约的**数值**必须与明文一致,尤其非 2 的幂(最后一个是轮空,不是补哑元素)。
|
||
///
|
||
/// 也顺带覆盖负数:`MAX` 的补位是负哨兵,符号与补位交互错过的话这里会红。
|
||
#[test]
|
||
fn minmax_tree_matches_plaintext_across_sizes() {
|
||
for n in [1usize, 2, 3, 4, 5, 6, 7, 8, 9, 16, 17, 33] {
|
||
let data: Vec<f64> = (0..n).map(|i| ((i * 37 % 1001) as f64) - 400.0).collect();
|
||
let want_min = data.iter().copied().fold(f64::INFINITY, f64::min);
|
||
let want_max = data.iter().copied().fold(f64::NEG_INFINITY, f64::max);
|
||
let aggs = [Agg::Count, Agg::Min, Agg::Max];
|
||
let (got, _) = {
|
||
let sh = shares_of(&[&data]);
|
||
run_two(
|
||
sh,
|
||
move |v, s| secure_aggregate_all(v, &s[0], &aggs),
|
||
move |v, s| secure_aggregate_all(v, &s[0], &aggs),
|
||
)
|
||
};
|
||
assert_eq!(got[0], n as f64, "n={n} COUNT");
|
||
assert_eq!(got[1], want_min, "n={n} MIN");
|
||
assert_eq!(got[2], want_max, "n={n} MAX");
|
||
}
|
||
}
|