Files
admin 54781b3f83
ci / gate (push) Waiting to run
refactor: 项目改名 ssw-mpc,crate 统一到 mpc-* 前缀
- 项目与文档标题: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
2026-11-05 15:06:12 +08:00

371 lines
15 KiB
Rust
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! 整数分组码(`GroupMode::IntegerCode`)的对拍与契约测试。
//!
//! 这里的每一条都在回答「这条捷径到底能不能用」:
//!
//! * 与逐组比较(`GroupMode::Exact`)**逐位相同** —— 捷径不是新算法,是同一条
//! 语义的另一条建图路径;
//! * 越界码被丢掉、非整数码落到上方最近一组 —— 这是**契约**,不是 bug,所以
//! 用测试钉住它,而不是等它在生产里悄悄发生;
//! * 轮数确实更少,且少多少能报出来。
use mpc_core::ring;
use mpc_sql::secure::{
query_rounds, secure_group_by, secure_group_by_coded, secure_group_by_pred,
secure_group_by_pred_coded, Agg, CmpOp, GroupMode, Pred,
};
use mpc_vault::{Pipe, Vault, VaultError};
const FXP: u32 = 18;
fn enc(v: &[f64]) -> Vec<u64> {
v.iter().map(|x| ring::encode(*x, FXP).unwrap()).collect()
}
/// 把一份明文分成两片(用一个临时 Vault 发牌)。
fn split(vals: &[f64]) -> (Vec<u64>, Vec<u64>) {
let mut v = Vault::new(Pipe::pair().0, "alice", &["alice", "bob"], [7u8; 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 侧结果, bob 侧结果)`。
///
/// 用 `thread::scope` 而不是 `spawn`:闭包要借本地的 `codes` 切片,
/// `'static` 那条约束是多余的。
fn run_pair<F>(cols: &[&[f64]], f: F) -> (Vec<Vec<f64>>, Vec<Vec<f64>>)
where
F: Fn(usize, &mut Vault<Pipe>, &[Vec<u64>]) -> Result<Vec<Vec<f64>>, VaultError> + Sync,
{
let shares: Vec<(Vec<u64>, Vec<u64>)> = cols.iter().map(|c| split(c)).collect();
let sites = ["alice", "bob"];
let seed = [13u8; 32];
let (pa, pb) = Pipe::pair();
let mut va = Vault::new(pa, "alice", &sites, seed, FXP).unwrap();
let mut vb = Vault::new(pb, "bob", &sites, seed, FXP).unwrap();
let a: Vec<Vec<u64>> = shares.iter().map(|(x, _)| x.clone()).collect();
let b: Vec<Vec<u64>> = shares.iter().map(|(_, y)| y.clone()).collect();
std::thread::scope(|s| {
let h = s.spawn(|| f(1, &mut vb, &b));
let out = f(0, &mut va, &a).unwrap();
(out, h.join().unwrap().unwrap())
})
}
/// 只要 alice 侧结果。
fn run_one<F>(cols: &[&[f64]], f: F) -> Vec<Vec<f64>>
where
F: Fn(usize, &mut Vault<Pipe>, &[Vec<u64>]) -> Result<Vec<Vec<f64>>, VaultError> + Sync,
{
run_pair(cols, f).0
}
/// 两方都要拿到的错误(只在一侧报错说明建图不一致)。
fn run_err<F>(cols: &[&[f64]], f: F) -> VaultError
where
F: Fn(usize, &mut Vault<Pipe>, &[Vec<u64>]) -> Result<Vec<Vec<f64>>, VaultError> + Sync,
{
let shares: Vec<(Vec<u64>, Vec<u64>)> = cols.iter().map(|c| split(c)).collect();
let sites = ["alice", "bob"];
let seed = [17u8; 32];
let (pa, pb) = Pipe::pair();
let mut va = Vault::new(pa, "alice", &sites, seed, FXP).unwrap();
let mut vb = Vault::new(pb, "bob", &sites, seed, FXP).unwrap();
let a: Vec<Vec<u64>> = shares.iter().map(|(x, _)| x.clone()).collect();
let b: Vec<Vec<u64>> = shares.iter().map(|(_, y)| y.clone()).collect();
std::thread::scope(|s| {
let h = s.spawn(|| f(1, &mut vb, &b));
let out = f(0, &mut va, &a);
let other = h.join().unwrap();
match (out, other) {
(Err(e), Err(_)) => e,
(Err(e), Ok(_)) => e,
(Ok(_), Err(e)) => e,
(Ok(_), Ok(_)) => panic!("期望两侧都报错,实际都成功了"),
}
})
}
// --------------------------------------------------------------------------- //
// 1. 与逐组比较对拍
// --------------------------------------------------------------------------- //
const AMOUNTS: [f64; 5] = [100.0, 500.0, 250.0, 600.0, 300.0];
const CODES_3: [f64; 5] = [0.0, 1.0, 0.0, 2.0, 1.0];
const AGGS: [Agg; 3] = [Agg::Count, Agg::Sum, Agg::Avg];
fn both_modes(pred: Option<(f64, CmpOp)>, n_groups: usize, codes: &[f64]) -> (Vec<Vec<f64>>, Vec<Vec<f64>>) {
let exact = run_one(&[&AMOUNTS, codes], |_, v, cs| {
secure_group_by(v, &cs[0], &cs[1], n_groups, pred, &AGGS, 0)
});
let coded = run_one(&[&AMOUNTS, codes], |_, v, cs| {
secure_group_by_coded(v, &cs[0], &cs[1], n_groups, pred, &AGGS, 0)
});
(exact, coded)
}
fn assert_same(exact: &[Vec<f64>], coded: &[Vec<f64>], what: &str) {
assert_eq!(exact.len(), coded.len(), "{what}:组数不同");
for (g, (e, c)) in exact.iter().zip(coded.iter()).enumerate() {
for (k, (a, b)) in e.iter().zip(c.iter()).enumerate() {
match AGGS[k] {
// COUNT / SUM 是整数,两条路径必须**逐位相同**。
Agg::Count | Agg::Sum => assert_eq!(
a, b,
"{what}:组 {g} 的 {:?} 不同(exact={a} coded={b})",
AGGS[k]
),
// AVG 的两条路径除法不一样,这是**唯一**会有差的地方:
// Exact 走 `scale(sum, 1/count)`,系数被量化到 `2^-fxp`
// (`1/5` 这种除不尽的最多差 `sum·2^-fxp`);coded 拿到精确整数和
// 之后在明文侧除,没有这层量化。所以按**相对**误差比。
Agg::Avg => {
if a.is_nan() {
assert!(b.is_nan(), "{what}:组 {g} 空组语义不同");
} else {
let tol = 1e-4 * a.abs().max(1.0);
assert!(
(a - b).abs() <= tol,
"{what}:组 {g} 的 AVG 差太多(exact={a} coded={b},容差 {tol})"
);
}
}
Agg::Min | Agg::Max => unreachable!("这组测试不请求 MIN/MAX"),
}
}
}
}
#[test]
fn coded_matches_exact_without_where() {
let (exact, coded) = both_modes(None, 3, &CODES_3);
assert_same(&exact, &coded, "无 WHERE");
// 顺手把期望值钉住:组 0 两行(100+250)、组 1 两行(500+300)、组 2 一行。
assert_eq!(coded[0][0], 2.0);
assert_eq!(coded[0][1], 350.0);
assert_eq!(coded[1][1], 800.0);
assert_eq!(coded[2][1], 600.0);
assert_eq!(coded[2][2], 600.0);
}
#[test]
fn coded_matches_exact_with_where() {
let (exact, coded) = both_modes(Some((300.0, CmpOp::Lt)), 3, &CODES_3);
assert_same(&exact, &coded, "带 WHERE");
// col < 300 只剩 100、250,都在 0 号组。
assert_eq!(coded[0][0], 2.0);
assert_eq!(coded[0][1], 350.0);
assert_eq!(coded[1][0], 0.0, "1 号组应当被 WHERE 清空");
}
/// 复合谓词版(`secure_group_by_pred_coded`):与 `secure_group_by_pred` 对拍。
///
/// 这条路径多了两件事:谓词作用在**多列**上、聚合列在下标 `agg_col` 而不是 0。
/// 前缀段的输入布局是「用户列 ++ 分组码」,这两点任一处错位都只表现为数值不对
/// (不会崩),所以必须对着 Exact 跑一遍。
#[test]
fn coded_pred_matches_exact() {
let spend: [f64; 5] = [50.0, 100.0, 10.0, 700.0, 20.0];
let cols: [&[f64]; 3] = [&AMOUNTS, &spend, &CODES_3];
// WHERE amount < 400 AND spend > 5
let pred = Pred::And(
Box::new(Pred::Cmp {
col: 0,
op: CmpOp::Lt,
threshold: 400.0,
}),
Box::new(Pred::Cmp {
col: 1,
op: CmpOp::Gt,
threshold: 5.0,
}),
);
let exact = run_one(&cols, |_, v, cs| {
secure_group_by_pred(v, cs, 0, &cs[2], 3, Some(&pred), &AGGS, 0)
});
let coded = run_one(&cols, |_, v, cs| {
secure_group_by_pred_coded(v, cs, 0, &cs[2], 3, Some(&pred), &AGGS, 0)
});
assert_same(&exact, &coded, "复合谓词");
// 命中第 0/2/4 行(100、250、300),码分别是 0、0、1:
// 组 0 两行 350,组 1 一行 300,组 2 空。
assert_eq!(coded[0][0], 2.0);
assert_eq!(coded[0][1], 350.0);
assert_eq!(coded[1][0], 1.0);
assert_eq!(coded[1][1], 300.0);
assert_eq!(coded[2][0], 0.0);
assert!(coded[2][2].is_nan(), "空组的 AVG 是 NaN");
}
// --------------------------------------------------------------------------- //
// 2. 契约:越界码与非整数码
// --------------------------------------------------------------------------- //
/// 越界码(`< 0` 或 `>= n_groups`)被丢掉 —— 与逐组比较一致。
#[test]
fn coded_drops_out_of_range_codes() {
let codes = [0.0, 1.0, 5.0, -1.0, 2.0];
let (exact, coded) = both_modes(None, 2, &codes);
assert_same(&exact, &coded, "越界码");
// `5` 和 `−1` 都越界(`5` ≥ N=2、`−1` < 0),只剩码 0 和 1 两行。
assert_eq!(coded[0][0], 1.0);
assert_eq!(coded[1][0], 1.0);
let total: f64 = coded.iter().map(|r| r[0]).sum();
assert_eq!(total, 2.0, "5 行里只有 2 行的码落在 0..2 内");
}
/// **非整数码落到上方最近的一组**(`1.5 → 2 号组`)。
///
/// 这是 `GroupMode::IntegerCode` 与 `Exact` 唯一会给出不同数字的地方,属于契约,
/// 不是缺陷:浮点码当分组码用,本来就该先用 `binning` 落成整数码再进密态。
#[test]
fn coded_treats_non_integer_code_as_ceiling() {
let codes = [0.0, 1.5, 2.0, 0.4, 0.6];
let (exact, coded) = both_modes(None, 3, &codes);
// 逐组比较:1.5 / 0.4 / 0.6 谁都不属于,只有 0.0 与 2.0 两行有组。
assert_eq!(exact[0][0], 1.0);
assert_eq!(exact[1][0], 0.0);
assert_eq!(exact[2][0], 1.0);
// 前缀和:它们被吸到上方最近的整数组。
assert_eq!(coded[0][0], 2.0, "0.0 和 0.4 都算 0 号组");
assert_eq!(coded[1][0], 1.0, "0.6 落到 1 号组");
assert_eq!(coded[2][0], 2.0, "1.5 和 2.0 落到 2 号组");
}
/// `MIN` / `MAX` 不能用前缀和还原 —— 直接拒,不静默降级。
#[test]
fn coded_rejects_min_max() {
let err = run_err(&[&AMOUNTS, &CODES_3], |_, v, cs| {
secure_group_by_coded(v, &cs[0], &cs[1], 3, None, &[Agg::Min], 0)
});
let msg = err.to_string();
assert!(
msg.contains("MIN") && msg.contains("Exact"),
"报错该说清「不支持 MIN/MAX,请改用 Exact」,实际:{msg}"
);
}
/// 空组的语义与 `Exact` 一致:`COUNT`/`SUM` 是 0,`AVG` 是 `NaN`。
#[test]
fn coded_empty_group_keeps_exact_semantics() {
let codes = [0.0, 0.0, 0.0, 0.0, 0.0];
let (exact, coded) = both_modes(None, 2, &codes);
assert_same(&exact, &coded, "空组");
assert_eq!(coded[1][0], 0.0);
assert_eq!(coded[1][1], 0.0);
assert!(coded[1][2].is_nan());
}
/// k-匿名抑制:组太小整行 `NaN`,与 `Exact` 一致。
#[test]
fn coded_respects_k_anonymity() {
let rows = run_one(&[&AMOUNTS, &CODES_3], |_, v, cs| {
secure_group_by_coded(v, &cs[0], &cs[1], 3, None, &AGGS, 3)
});
// 每组最多 2 行,阈值 3 → 全部抑制。
for (g, row) in rows.iter().enumerate() {
assert!(
row.iter().all(|v| v.is_nan()),
"组 {g} 应当被抑制,实际 {row:?}"
);
}
}
/// 单组(`n_groups == 1`)时前缀只剩两个边界,结果应与整表聚合完全一致。
///
/// 注意 `n_groups == 1` 只认码 `0`:码 `1`、`2` 都算越界(`≥ N`)被丢掉 ——
/// 边界值就是 `−0.5` 与 `0.5`,没有第三个边界可给它们。
#[test]
fn coded_single_group_equals_whole_table() {
let all_zero = [0.0; 5];
let rows = run_one(&[&AMOUNTS, &all_zero], |_, v, cs| {
secure_group_by_coded(v, &cs[0], &cs[1], 1, None, &AGGS, 0)
});
assert_eq!(rows.len(), 1);
assert_eq!(rows[0][0], 5.0, "5 行全在唯一的一组里");
assert_eq!(rows[0][1], 1750.0);
assert!((rows[0][2] - 350.0).abs() < 1e-9);
}
// --------------------------------------------------------------------------- //
// 3. 轮数:确实更少,且能报出来
// --------------------------------------------------------------------------- //
#[test]
fn coded_costs_fewer_rounds_and_the_number_is_reported() {
let agg = [Agg::Count, Agg::Sum];
for n in [2usize, 4, 8] {
let exact = query_rounds(8, FXP, 1, None, Some(n), &agg, GroupMode::Exact).unwrap();
let coded = query_rounds(8, FXP, 1, None, Some(n), &agg, GroupMode::IntegerCode).unwrap();
assert!(
coded.rounds() < exact.rounds(),
"{n} 组时整数码模式应当更少:exact {} vs coded {}",
exact.rounds(),
coded.rounds()
);
// 整数码模式下没有第二段:所有组的输出在一次批量 open 里出来。
assert_eq!(coded.agg_rounds(), 0);
assert!(coded.aggs.is_none());
// **组数不再影响轮数**:同阶段的比较合成一批(`sec_cmp_batch`),
// 9 轮封顶,与有几个组无关。批量之前这里是「每组 18~20 轮」。
assert_eq!(
coded.rounds(),
12,
"{n} 组的轮数应当与组数无关(批量比较),实际 {}",
coded.rounds()
);
assert_eq!(exact.rounds(), 13, "{n} 组的逐组比较也应是常数轮");
}
// 钉住实测值:8 组逐组 162(未做批量比较时)→ 现在 13 / 12。
let exact = query_rounds(8, FXP, 1, None, Some(8), &agg, GroupMode::Exact).unwrap();
let coded = query_rounds(8, FXP, 1, None, Some(8), &agg, GroupMode::IntegerCode).unwrap();
assert_eq!(exact.rounds(), 13);
assert_eq!(coded.rounds(), 12);
}
/// 带 WHERE 只多「一次比较 + 一次码搬家乘」。
#[test]
fn coded_where_costs_only_the_park_mul() {
let agg = [Agg::Count, Agg::Sum];
let free = query_rounds(8, FXP, 1, None, Some(4), &agg, GroupMode::IntegerCode).unwrap();
let pred = Pred::Cmp {
col: 0,
op: CmpOp::Lt,
threshold: 300.0,
};
let with_where = query_rounds(
8,
FXP,
1,
Some(&pred),
Some(4),
&agg,
GroupMode::IntegerCode,
)
.unwrap();
// WHERE 本身一次比较(9 轮)+ 码搬家一次 mul_raw(2 轮)= 11 轮;
// 实测 10,因为有一轮 `open` 恰好并进了搬家那个阶段。
let extra = with_where.rounds() - free.rounds();
assert!(
(9..=11).contains(&extra),
"带 WHERE 只该多「一次比较 + 一次搬家乘」(9~11 轮),实际 {extra}:{} → {}",
free.rounds(),
with_where.rounds()
);
}
/// 整数码模式下 `fxp == 0` 必须报错:`g + 0.5` 会被舍成整数,边界全错一位。
#[test]
fn coded_rejects_fxp_zero() {
let err = match query_rounds(8, 0, 1, None, Some(4), &[Agg::Count], GroupMode::IntegerCode) {
Ok(_) => panic!("fxp=0 必须报错"),
Err(e) => e,
};
assert!(err.to_string().contains("fxp"), "实际:{err}");
}