From 355d1be699359cfc534c53aad8294c6ad4e7e65a Mon Sep 17 00:00:00 2001 From: rong Date: Fri, 30 Oct 2026 18:32:05 +0800 Subject: [PATCH] =?UTF-8?q?feat(ml):=20=E7=BA=B5=E5=90=91=20LR=20=E6=8E=A5?= =?UTF-8?q?=20PSI=20=E8=A1=8C=E5=AF=B9=E9=BD=90?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 影响:两方各持不同客户名单时,能先 PSI 求交再密态训练纵向 LR; 此前 demo 隐含「行已对齐」,真实业务走不通。 - `nax_psi::align_by_key`:从测试上提为公开函数(PSI 结果的后处理), 按共享键字节序排序;键重复即报错(一对多 join 不支持)。 - `run_lr_vertical_session`:两方各持不同客户、不同特征列的完整纵向 LR, PSI → align → 0 分片拼接列块。列块排布在碰网络前就校验。 - 新增 `tests/lr_vertical_psi.rs`(4 测):含变异检验——去掉排序后 2 条红。 --- crates/nax-node/src/lib.rs | 222 ++++++++++++++++ crates/nax-node/tests/lr_vertical_psi.rs | 311 +++++++++++++++++++++++ crates/nax-psi/src/lib.rs | 36 +++ 3 files changed, 569 insertions(+) create mode 100644 crates/nax-node/tests/lr_vertical_psi.rs diff --git a/crates/nax-node/src/lib.rs b/crates/nax-node/src/lib.rs index 99b732a..b842d76 100644 --- a/crates/nax-node/src/lib.rs +++ b/crates/nax-node/src/lib.rs @@ -672,6 +672,228 @@ pub fn run_lr_session( Ok(w) } +/// 真实纵向 LR 的配置:两方各持**不同客户**、**不同特征列**。 +/// +/// 与 [`LrConfig`] 的区别:那个假设两方行已对齐、列形状相同(demo 用, +/// 两方传同一份数据即可);这个从 PSI 开始 —— 行由求交决定,列由公开 schema 定位。 +pub struct VerticalLrConfig { + /// 本方 site 名。 + pub site: String, + /// 全体参与方(含本方)。目前只支持两方。 + pub sites: Vec, + /// 密态会话主种子(派生 Beaver 物料,**两方必须一致**)。 + pub seed: [u8; 32], + /// 定点小数位。 + pub fxp: u32, + /// 本方的 join 键(PSI 输入,长度 = 本方样本数)。 + pub ids: Vec>, + /// PSI 会话种子。两方**必须不同** —— 同种子等于双方私钥相同, + /// ECDH 退化成共享标量,测不出真实的交换律。 + pub psi_seed: [u8; 32], + /// 本方特征,行主序 `n_own × d_own`。 + pub x: Vec, + /// 本方贡献的列数。 + pub d_own: usize, + /// 本方列在**全局列序**里的起点(公开 schema)。 + pub col_offset: usize, + /// 全局总列数(两方必须一致,等于两方 `d_own` 之和)。 + pub d_total: usize, + /// 本方标签(长度 `n_own`);本方不持标签时留空,由对端提供。 + pub y: Vec, + /// 训练轮数。 + pub epochs: usize, + /// 学习率。 + pub lr: f64, +} + +/// 跑一次**真纵向** LR:先 PSI 求交、再按共享键对齐、再密态训练。 +/// +/// # 两条连接 +/// +/// PSI 与密态会话必须走**两条独立连接**。混用同一条会让帧串到对端的 +/// `recv` 上 —— `PsiPoints` 与 `Shares` 的 op 不同,直接报协议错。 +/// +/// # 列怎么拼成一行 +/// +/// 两方各持自己的列块,在自己**不持有的列位置填 0 分片**,加和恰好 +/// 等于列拼接 —— 因为两方的分片各自只在自己的列位置非零。 +/// 所以 `VerticalLR::fit` 不用改:它看到的 `x_sh` 加和就是 +/// `n × d_total` 的完整特征矩阵。 +/// +/// # 返回 +/// +/// `(对齐后的本方行下标, 权重)`。行下标是**本方原始行序**, +/// 调用方可用它核对两方是否对齐到了同一批样本。 +pub fn run_lr_vertical_session( + psi_transport: T, + vault_transport: T, + cfg: &VerticalLrConfig, + verbose: bool, +) -> Result<(Vec, Vec), NodeError> { + use nax_ml::VerticalLR; + + if cfg.sites.len() != 2 { + return Err(NodeError::Session(format!( + "纵向 LR 目前只支持两方,得到 {} 方", + cfg.sites.len() + ))); + } + if cfg.x.len() != cfg.ids.len() * cfg.d_own { + return Err(NodeError::Session(format!( + "特征长度 {} ≠ 样本数 {} × 本方列数 {}", + cfg.x.len(), + cfg.ids.len(), + cfg.d_own + ))); + } + if !cfg.y.is_empty() && cfg.y.len() != cfg.ids.len() { + return Err(NodeError::Session(format!( + "标签长度 {} ≠ 样本数 {}", + cfg.y.len(), + cfg.ids.len() + ))); + } + if cfg.col_offset + cfg.d_own > cfg.d_total { + return Err(NodeError::Session(format!( + "本方列块 [{}, {}) 超出总列数 {}", + cfg.col_offset, + cfg.col_offset + cfg.d_own, + cfg.d_total + ))); + } + + // 列块排布在**碰网络之前**就要定下来:两方场景只有两种合法排布 + // (本方在前 / 本方在后)。悬空的列块会让拼出来的矩阵静默错位, + // 所以宁可在这里拒绝,也不要等到 PSI 跑完才发现。 + let d_peer = cfg.d_total - cfg.d_own; + let peer_off = if cfg.col_offset == 0 { + cfg.d_own + } else if cfg.col_offset == d_peer { + 0 + } else { + return Err(NodeError::Session(format!( + "列块 [{}, {})、总列数 {} —— 只支持两方列块首尾相接(col_offset 必须为 0 或 {})", + cfg.col_offset, + cfg.col_offset + cfg.d_own, + cfg.d_total, + d_peer + ))); + }; + + // 1) PSI:本方交集下标(本地行序升序) + let psi_cfg = PsiConfig { + site: cfg.site.clone(), + sites: cfg.sites.clone(), + ids: cfg.ids.clone(), + seed: cfg.psi_seed, + }; + let hits = run_psi_session(psi_transport, &psi_cfg, verbose)?; + log(verbose, &format!("PSI 交集 {} 条", hits.len())); + + // 2) 按共享规范键排序 —— 两方得到同一个顺序 + let order = nax_psi::align_by_key(&cfg.ids, &hits).map_err(NodeError::Session)?; + let n = order.len(); + log(verbose, &format!("对齐后 {n} 行")); + + // 3) 只留交集行,并按对齐行序重排本方特征 + let mut x_aligned = Vec::with_capacity(n * cfg.d_own); + for &row in &order { + x_aligned.extend_from_slice(&cfg.x[row * cfg.d_own..(row + 1) * cfg.d_own]); + } + let x_enc: Vec = x_aligned + .iter() + .map(|v| ring::encode(*v, cfg.fxp).map_err(|e| NodeError::Session(e.to_string()))) + .collect::>()?; + + // 4) 分片交换:本方留一片、对端给一片(先全发再全收,避免双向死锁) + let site_refs: Vec<&str> = cfg.sites.iter().map(|s| s.as_str()).collect(); + let mut vault = Vault::new(vault_transport, &cfg.site, &site_refs, cfg.seed, cfg.fxp)?; + let peer_idx = 1 - vault.my_index(); + + let all_x = vault.split(&x_enc)?; + let x_mine = vault.my_slice(&all_x)?.to_vec(); + vault.send_share(peer_idx, &all_x)?; + let x_peer = vault.recv_share()?; + + if x_mine.len() != n * cfg.d_own { + return Err(NodeError::Session(format!( + "本方分片长度 {} ≠ n×d_own = {}×{}", + x_mine.len(), + n, + cfg.d_own + ))); + } + if x_peer.len() != n * d_peer { + return Err(NodeError::Session(format!( + "对端分片长度 {} ≠ n×d_peer = {}×{} —— 两方对 d_total/d_own 的理解不一致", + x_peer.len(), + n, + d_peer + ))); + } + + // 5) 拼全局列序(`peer_off` / `d_peer` 已在入口定好并校验过) + let mut x_sh = vec![0u64; n * cfg.d_total]; + for i in 0..n { + for k in 0..cfg.d_own { + x_sh[i * cfg.d_total + cfg.col_offset + k] = x_mine[i * cfg.d_own + k]; + } + // 对端列块:加和即拼接(本方在这些位置是 0) + for k in 0..d_peer { + let slot = &mut x_sh[i * cfg.d_total + peer_off + k]; + *slot = slot.wrapping_add(x_peer[i * d_peer + k]); + } + } + log( + verbose, + &format!("特征拼接完成 ({n} 行 × {} 列)", cfg.d_total), + ); + + // 6) 标签:只有一方提供,另一方按全零分片参与(全零 split 后加和为 0) + let y_enc: Vec = if cfg.y.is_empty() { + vec![0u64; n] + } else { + let mut out = Vec::with_capacity(n); + for &row in &order { + out.push( + ring::encode(cfg.y[row], cfg.fxp) + .map_err(|e| NodeError::Session(e.to_string()))?, + ); + } + out + }; + let all_y = vault.split(&y_enc)?; + let y_mine = vault.my_slice(&all_y)?.to_vec(); + vault.send_share(peer_idx, &all_y)?; + let y_peer = vault.recv_share()?; + let y_sh: Vec = y_mine + .iter() + .zip(y_peer.iter()) + .map(|(a, b)| a.wrapping_add(*b)) + .collect(); + log(verbose, "y 分片交换完成"); + + // 7) 训练(d 传全局列数,两方一致) + let model = VerticalLR { + lr: cfg.lr, + epochs: cfg.epochs, + l2: 0.0, + sigmoid_degree: 7, + fit_intercept: true, + }; + log( + verbose, + &format!("开始训练 ({} 轮, lr={}, d_total={})", cfg.epochs, cfg.lr, cfg.d_total), + ); + let w_sh = model + .fit(&mut vault, &x_sh, n, cfg.d_total, &y_sh) + .map_err(|e| NodeError::Session(e.to_string()))?; + + let w = vault.reveal(&w_sh)?; + log(verbose, "训练完成"); + Ok((order, w)) +} + #[cfg(test)] mod tests { use super::*; diff --git a/crates/nax-node/tests/lr_vertical_psi.rs b/crates/nax-node/tests/lr_vertical_psi.rs new file mode 100644 index 0000000..9031f3b --- /dev/null +++ b/crates/nax-node/tests/lr_vertical_psi.rs @@ -0,0 +1,311 @@ +//! 真纵向 LR 端到端:两方各持**不同客户**、**不同特征列**。 +//! +//! ```text +//! PSI(本方交集下标,本地行序) +//! → nax_psi::align_by_key(按共享键字节序重排,两方同一顺序) +//! → 各在自己不持有的列位置填 0 分片 → 加和即列拼接 +//! → VerticalLR::fit(密态)→ reveal → 对拍明文 +//! ``` +//! +//! # 这条测试要守什么 +//! +//! 既有的 `nax lr` demo 要求两方传**同一份**数据(`LrConfig` 里 `d` 是 +//! "每人贡献的列数",加和后仍是 d 列)。真实纵向场景是反过来的: +//! 客户名单只部分重叠,特征各持一半。这条测试覆盖后者 —— +//! alice 只有 `balance`,bob 只有 `spend`/`region`,交集 7 人, +//! 训练出的 4 个权重(3 列 + 偏置)必须与明文 LR 高度一致。 +//! +//! # 为什么数据要标准化到 ±1 +//! +//! 密态 sigmoid 是 7 次奇多项式,只在拟合区间 `|z| ≤ R = 6` 内有效。 +//! 原始量纲(余额几百、消费几十)会让 `z = X·w` 立刻冲出区间, +//! 训练必然发散 —— 那是数值问题,不是协议问题,不该混进这条测试。 + +use std::thread; + +use nax_core::ring; +use nax_ml::plaintext_lr; +use nax_node::{run_lr_vertical_session, VerticalLrConfig}; +use nax_psi::id_from_u64; +use nax_vault::Pipe; + +const FXP: u32 = 18; +const SITES: [&str; 2] = ["alice", "bob"]; + +/// 一方:自己的客户名单 + 自己的特征列 + 可能的标签。 +#[derive(Clone)] +struct Party { + site: &'static str, + /// PSI 会话种子。两方**故意不同** —— 同种子等于双方私钥相同。 + psi_seed: [u8; 32], + ids: Vec, + /// 每列一个 Vec,长度都等于 `ids.len()`。 + cols: Vec>, + y: Vec, +} + +impl Party { + fn keys(&self) -> Vec> { + self.ids.iter().map(|v| id_from_u64(*v)).collect() + } + + fn d_own(&self) -> usize { + self.cols.len() + } + + /// 行主序平铺。 + fn x_flat(&self) -> Vec { + let n = self.ids.len(); + let mut out = Vec::with_capacity(n * self.cols.len()); + for i in 0..n { + for c in &self.cols { + out.push(c[i]); + } + } + out + } +} + +// --------------------------------------------------------------------------- +// 数据:alice 持 (id, balance),bob 持 (uid, spend, region, y) +// +// alice ids: 7 2 4 1 8 3 9 5 +// bob ids: 4 9 2 3 5 1 6 8 +// 交集 = {1,2,3,4,5,8,9},7 条(key 6 只有 bob 有,key 7 只有 alice 有) +// +// 两方本地行序**互不相同**,且交集在两侧的位置序列不同: +// alice 交集位置 = [3,1,5,2,7,4,6] +// bob 交集位置 = [5,2,3,0,4,7,1] +// 不排序直接拼列 = 行错位,结果不崩但数不对。 +// --------------------------------------------------------------------------- + +fn sample() -> (Party, Party) { + // 按 key 1,2,3,4,5,8,9 的明文取值见 `plaintext_expected()`。 + // 这里按**各自本地行序**填,所以下面的数组看起来"乱"——那是故意的。 + + // alice 行序 7,2,4,1,8,3,9,5 → key 7 不在交集,填 0 + let alice = Party { + site: "alice", + psi_seed: [0x11; 32], + ids: vec![7, 2, 4, 1, 8, 3, 9, 5], + // key: 7 2 4 1 8 3 9 5 + cols: vec![vec![0.0, -0.75, -0.25, -1.0, 0.75, -0.5, 1.0, 0.0]], + y: vec![], + }; + + // bob 行序 4,9,2,3,5,1,6,8 → key 6 不在交集(填 0) + let bob = Party { + site: "bob", + psi_seed: [0x22; 32], + ids: vec![4, 9, 2, 3, 5, 1, 6, 8], + cols: vec![ + // 4 9 2 3 5 1 6 8 + vec![-0.25, 1.0, -0.75, -0.5, 0.0, -1.0, 0.0, 0.75], // spend + vec![0.5, 0.5, 0.0, 0.0, 0.5, 0.0, 0.0, 0.5], // region + ], + y: vec![1.0, 1.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0], + }; + (alice, bob) +} + +/// 对齐后(key 1,2,3,4,5,8,9)的明文特征矩阵与标签,用于对照。 +fn plaintext_expected() -> (Vec, Vec) { + // key: 1 2 3 4 5 8 9 + let x = vec![ + -1.0, -1.0, 0.0, // key 1 + -0.75, -0.75, 0.0, // key 2 + -0.5, -0.5, 0.0, // key 3 + -0.25, -0.25, 0.5, // key 4 + 0.0, 0.0, 0.5, // key 5 + 0.75, 0.75, 0.5, // key 8 + 1.0, 1.0, 0.5, // key 9 + ]; + let y = vec![0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0]; + (x, y) +} + +fn cfg_of(p: &Party, col_offset: usize, d_total: usize) -> VerticalLrConfig { + VerticalLrConfig { + site: p.site.to_string(), + sites: SITES.iter().map(|s| s.to_string()).collect(), + seed: [0x5Bu8; 32], // 密态主种子:两方必须一致 + fxp: FXP, + ids: p.keys(), + psi_seed: p.psi_seed, + x: p.x_flat(), + d_own: p.d_own(), + col_offset, + d_total, + y: p.y.clone(), + // lr 必须温和:sigmoid 是 7 次多项式,只在 |z| ≤ R = 6 内有效。 + // 步长稍大一点 w 就会过冲,z 冲出区间 → 多项式爆炸 → 不可逆发散。 + // 这是数值问题,与 PSI / 对齐无关,所以参数要和明文对照取同一组。 + epochs: 40, + lr: 0.3, + } +} + +/// 一方的会话输出:`(对齐行下标, 权重)`,或失败原因。 +type PartyOut = Result<(Vec, Vec), String>; + +/// 跑两方会话,返回两方各自的结果。 +fn run_pair(a: &Party, b: &Party) -> (PartyOut, PartyOut) { + let d_total = a.d_own() + b.d_own(); + let (psi_a, psi_b) = Pipe::pair(); + let (va, vb) = Pipe::pair(); + + let ca = cfg_of(a, 0, d_total); + let cb = cfg_of(b, a.d_own(), d_total); + + let ha = thread::spawn(move || { + run_lr_vertical_session(psi_a, va, &ca, false) + .map_err(|e| e.to_string()) + }); + let hb = thread::spawn(move || { + run_lr_vertical_session(psi_b, vb, &cb, false) + .map_err(|e| e.to_string()) + }); + ( + ha.join().expect("alice 线程 panic"), + hb.join().expect("bob 线程 panic"), + ) +} + +fn decode_weights(w: &[u64]) -> Vec { + w.iter().map(|&v| ring::decode(v, FXP)).collect() +} + +/// 皮尔逊相关系数。密态用 7 次多项式 sigmoid、明文用精确 sigmoid, +/// 两者的**收敛目标**一致但不逐位相同,所以按相关性验收(与 README 口径一致)。 +fn corr(a: &[f64], b: &[f64]) -> f64 { + assert_eq!(a.len(), b.len()); + let n = a.len() as f64; + let ma = a.iter().sum::() / n; + let mb = b.iter().sum::() / n; + let (mut cov, mut va, mut vb) = (0.0, 0.0, 0.0); + for i in 0..a.len() { + let da = a[i] - ma; + let db = b[i] - mb; + cov += da * db; + va += da * da; + vb += db * db; + } + cov / (va.sqrt() * vb.sqrt()) +} + +/// 端到端:PSI → 对齐 → 列拼接 → 密态训练,权重对拍明文 LR。 +#[test] +fn vertical_lr_over_psi_matches_plaintext() { + let (a, b) = sample(); + let (x_plain, y_plain) = plaintext_expected(); + + let (ra, rb) = run_pair(&a, &b); + let (oa, wa) = ra.expect("alice 侧失败"); + let (ob, wb) = rb.expect("bob 侧失败"); + + // 两方必须对齐到**同一批样本**:交集 7 条,且权重一致(reveal 后同值) + assert_eq!(oa.len(), 7, "交集应为 7 条"); + assert_eq!(ob.len(), 7, "交集应为 7 条"); + assert_eq!(wa, wb, "两方 reveal 出的权重必须相同"); + + // 对齐后的键序列(用各自的行下标映射回 id) + let keys_a: Vec = oa.iter().map(|&i| a.ids[i]).collect(); + let keys_b: Vec = ob.iter().map(|&i| b.ids[i]).collect(); + assert_eq!(keys_a, keys_b, "两方对齐后的键序列必须逐条相同"); + assert_eq!( + keys_a, + vec![1, 2, 3, 4, 5, 8, 9], + "规范序 = 键的字节序(1<2<3<4<5<8<9)" + ); + + // 明文对照:同样的拼接特征、同样的 y(同一组超参) + let w_plain = plaintext_lr(&x_plain, &y_plain, 7, 3, 0.3, 40, 0.0, true); + let w_enc = decode_weights(&wa); + assert_eq!(w_enc.len(), 4, "3 列 + 偏置"); + + let r = corr(&w_plain, &w_enc); + assert!( + r > 0.95, + "密态权重与明文 LR 应高度一致,实际 r = {r:.4}\n 明文: {w_plain:?}\n 密态: {w_enc:?}" + ); + + // balance 与 spend 同向(两组特征取值相同、标签同向),二者权重应同号 + assert!( + w_enc[0] * w_enc[1] > 0.0, + "两列特征同向,权重应同号: {w_enc:?}" + ); +} + +/// 列拼接的正确性:若两方错位(不排序),拼出来的特征矩阵会串行。 +/// +/// 这条不跑密态,只验证「对齐后两方的行确实指向同一个 key」这个前提 —— +/// 它一旦不成立,上面的训练测试就算过了也是巧合。 +#[test] +fn psi_alignment_puts_same_person_on_same_row() { + let (a, b) = sample(); + let (ka, kb) = (a.keys(), b.keys()); + + // 明文模拟 PSI 的输出形状(本方交集下标、本地行序升序)。 + // 注意:交集判定要拿**对端**的键集合去查本方的键,不能拿自己查自己。 + let mut kb_sorted = kb.clone(); + kb_sorted.sort(); + let hits_a: Vec = (0..ka.len()) + .filter(|&i| kb_sorted.binary_search(&ka[i]).is_ok()) + .collect(); + let mut ka_sorted = ka.clone(); + ka_sorted.sort(); + let hits_b: Vec = (0..kb.len()) + .filter(|&i| ka_sorted.binary_search(&kb[i]).is_ok()) + .collect(); + + // PSI 返回的是**本地行序升序**的下标,不是按 key 排的 + assert_eq!(hits_a, vec![1, 2, 3, 4, 5, 6, 7], "alice 交集位置(本地行序)"); + assert_eq!(hits_b, vec![0, 1, 2, 3, 4, 5, 7], "bob 交集位置(本地行序)"); + + let oa = nax_psi::align_by_key(&ka, &hits_a).unwrap(); + let ob = nax_psi::align_by_key(&kb, &hits_b).unwrap(); + + // 对齐后 = 按 key 字节序重排,两方这才拿到同一个顺序 + assert_eq!(oa, vec![3, 1, 5, 2, 7, 4, 6], "alice 对齐后行序"); + assert_eq!(ob, vec![5, 2, 3, 0, 4, 7, 1], "bob 对齐后行序"); + + let sa: Vec<&Vec> = oa.iter().map(|&i| &ka[i]).collect(); + let sb: Vec<&Vec> = ob.iter().map(|&i| &kb[i]).collect(); + assert_eq!(sa, sb, "排序后两方键序列必须一致"); +} + +/// 交集为空:必须在训练前失败,而不是拿空列去跑 MPC。 +#[test] +fn disjoint_parties_fail_before_training() { + let a = Party { + site: "alice", + psi_seed: [0x11; 32], + ids: vec![1, 2], + cols: vec![vec![1.0, 2.0]], + y: vec![], + }; + let b = Party { + site: "bob", + psi_seed: [0x22; 32], + ids: vec![8, 9], + cols: vec![vec![3.0, 4.0]], + y: vec![0.0, 1.0], + }; + let (ra, rb) = run_pair(&a, &b); + // 两侧都该失败(PSI 交集为空 → align_by_key 报错) + assert!(ra.is_err(), "alice 侧应在训练前失败"); + assert!(rb.is_err(), "bob 侧应在训练前失败"); +} + +/// 配置自检:列块既不贴左也不贴右时报错,而不是拼出一个错的矩阵。 +#[test] +fn misaligned_column_block_is_rejected() { + let (a, _) = sample(); + // d_total=5、d_own=1、col_offset=2 → 中间悬空 + let cfg = cfg_of(&a, 2, 5); + let (psi, _psi_peer) = Pipe::pair(); + let (v, _v_peer) = Pipe::pair(); + // 对端缺席无所谓:入口校验在**碰网络之前**就该拒绝 + let r = run_lr_vertical_session(psi, v, &cfg, false); + assert!(r.is_err(), "悬空列块应在开始时被拒绝"); +} diff --git a/crates/nax-psi/src/lib.rs b/crates/nax-psi/src/lib.rs index f159b25..287e30f 100644 --- a/crates/nax-psi/src/lib.rs +++ b/crates/nax-psi/src/lib.rs @@ -133,6 +133,42 @@ pub fn resolve(perm: &[usize], positions: &[usize]) -> Vec { out } +/// 把「本方落在交集里的行」按**共享规范键**排序,返回按对齐行序排列的行下标。 +/// +/// # 为什么必须排序 +/// +/// [`resolve`] 返回的是**本地行序**升序的下标 —— 两方拿到的序列互不相同, +/// 也不含共享顺序。下游的纵向拼接(同一个人在两方各有一行,拼成一行特征) +/// 要求「两方第 i 行是同一个人」,所以两边必须按同一个**全序**重排。 +/// 这里用键的字节序:任何两方一致的全序都行,关键是别用本地行序。 +/// +/// 副作用(已知且接受):排序暴露了本方键相对对端键的秩,与 PSI 本身 +/// 泄露交集是同一量级的元信息;不排序则结果直接错 —— 不崩、不报错,就是数不对。 +/// +/// # 三种失败 +/// +/// - **交集为空**:两方没有公共样本。继续往下跑会拿空列去 open,在此明确失败。 +/// - **下标越界**:协议错乱的信号,不能当成正常情况处理。 +/// - **本方键重复**:对应一对多 join,纵向对齐(一人一行)表达不了笛卡尔展开, +/// 必须在切分片**之前**拒绝,而不是按行号静默错拼。 +pub fn align_by_key(keys: &[Vec], hits: &[usize]) -> Result, String> { + if hits.is_empty() { + return Err("交集为空:两方没有可对齐的行".into()); + } + if let Some(&bad) = hits.iter().find(|&&i| i >= keys.len()) { + return Err(format!("PSI 交集中出现越界下标 {bad}")); + } + let mut order = hits.to_vec(); + order.sort_by(|&x, &y| keys[x].cmp(&keys[y])); + if let Some(w) = order.windows(2).find(|w| keys[w[0]] == keys[w[1]]) { + return Err(format!( + "join 键在本方重复(第 {} 与第 {} 行),一对多 join 不支持", + w[0], w[1] + )); + } + Ok(order) +} + /// Fisher–Yates 洗牌,随机源用会话 PRG。 fn shuffle(v: &mut [usize], s: &mut Stream) { let n = v.len();