Files
ssw-mpc/crates/mpc-he/tests/he_protocol.rs
T
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

274 lines
10 KiB
Rust
Raw 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.
//! HE 协议语义测试:OLE / 无可信发牌方三元组 / PIR。
//!
//! 这些测试验证的是**协议数学**(重构后 a·b=c、PIR 查得准),
//! 不是逐位对照 —— 密文带随机因子,每次运行都不同。
//! 逐位对照在 `golden_paillier.rs` 里。
use mpc_core::prg::Stream;
use mpc_core::ring;
use mpc_core::share;
use mpc_he::bigint::{BigUint, Signed};
use mpc_he::ole;
use mpc_he::paillier::{self, KeyPair, PublicKey};
use mpc_he::pir;
use mpc_he::triple;
fn stream(seed: u8) -> Stream {
Stream::new(&[seed; 32])
}
fn quick_kp(seed: u8) -> KeyPair {
// 256-bit n:语义测试要快,安全性不是这里的关注点
paillier::keygen(256, &mut stream(seed)).expect("keygen")
}
#[test]
fn paillier_roundtrip_and_homomorphism() {
let kp = quick_kp(1);
let mut s = stream(2);
for m in [0u64, 1, 123456, u64::MAX] {
let c = kp.public.encrypt(&BigUint::from_u64(m), None, &mut s).unwrap();
let got = kp.private.decrypt_signed(&c);
assert_eq!(got.to_ring_u64(), m, "roundtrip m={m}");
}
// 负明文(Python 的 m %= n 语义)
let c = kp.public.encrypt_signed(&Signed::from_i64(-777), None, &mut s).unwrap();
let got = kp.private.decrypt_signed(&c);
assert!(got.neg && got.mag == BigUint::from_u64(777), "decrypt_signed(-777)");
// 同态:E(300) ⊞ E(45) = E(345)
let c1 = kp.public.encrypt(&BigUint::from_u64(300), None, &mut s).unwrap();
let c2 = kp.public.encrypt(&BigUint::from_u64(45), None, &mut s).unwrap();
let sum = kp.public.add(&c1, &c2);
assert_eq!(kp.private.decrypt_signed(&sum).to_ring_u64(), 345);
// 标量乘:E(21)^2 = E(42)
let c3 = kp.public.encrypt(&BigUint::from_u64(21), None, &mut s).unwrap();
let prod = kp.public.mul_plain(&c3, &BigUint::from_u64(2)).unwrap();
assert_eq!(kp.private.decrypt_signed(&prod).to_ring_u64(), 42);
}
#[test]
fn ciphertexts_are_randomized() {
let kp = quick_kp(3);
let mut s = stream(4);
let c1 = kp.public.encrypt(&BigUint::from_u64(7), None, &mut s).unwrap();
let c2 = kp.public.encrypt(&BigUint::from_u64(7), None, &mut s).unwrap();
assert_ne!(c1, c2, "同明文两次加密必须不同(IND-CPA)");
}
#[test]
fn ole_elementwise_reconstructs_product() {
// A 持 u,B 持 v;OLE 后 A 拿 u·v − t,B 拿 t,相加应得 u·v
let kp = quick_kp(5);
let mut sa = stream(6);
let mut sb = stream(7);
let u = [111u64, 222, 333, 444];
let v = [7u64, 8, 9, 10];
let mut t = [0u64; 4];
sb.fill_u64(&mut t);
let ca = ole::encrypt_ring(&kp.public, &u, &mut sa).unwrap();
let resp = ole::ole_respond(&kp.public, &ca, &v, &t, &mut sb).unwrap();
let a_share = ole::decrypt_ring(&kp.private, &resp); // u·v − t
for i in 0..4 {
let got = a_share[i].wrapping_add(t[i]);
let want = u[i].wrapping_mul(v[i]);
assert_eq!(got, want, "OLE 元素 {i}");
}
}
#[test]
fn ole_matmul_reconstructs_product() {
// Enc(A) @ B − T,A 持 u·v − T,B 持 T
let kp = quick_kp(8);
let mut sa = stream(9);
let mut sb = stream(10);
// A: 2×2,B: 2×2
let a = [1u64, 2, 3, 4];
let b = [5u64, 6, 7, 8];
let mut t = [0u64; 4];
sb.fill_u64(&mut t);
let ca = ole::encrypt_ring(&kp.public, &a, &mut sa).unwrap();
let resp = ole::ole_respond_matmul(&kp.public, &ca, (2, 2), &b, 2, &t, true, &mut sb).unwrap();
let a_share = ole::decrypt_ring(&kp.private, &resp);
let mut want = [0u64; 4];
ring::matmul_into(2, 2, 2, &a, &b, &mut want).unwrap();
for i in 0..4 {
assert_eq!(a_share[i].wrapping_add(t[i]), want[i], "矩阵 OLE 元素 {i}");
}
}
#[test]
fn he_mul_triple_consistent() {
// 无可信发牌方的三元组:重构后必须 a·b = c(环上)
let n = 2;
let len = 8;
let master = [42u8; 32];
let mut a = vec![0u64; n * len];
let mut b = vec![0u64; n * len];
let mut c = vec![0u64; n * len];
triple::mul_triple_into(n, len, &master, 256, &mut a, &mut b, &mut c).unwrap();
let (mut ra, mut rb, mut rc) = (vec![0u64; len], vec![0u64; len], vec![0u64; len]);
share::reconstruct_into(&a, n, len, &mut ra).unwrap();
share::reconstruct_into(&b, n, len, &mut rb).unwrap();
share::reconstruct_into(&c, n, len, &mut rc).unwrap();
let mut want = vec![0u64; len];
ring::mul_into(&ra, &rb, &mut want).unwrap();
assert_eq!(rc, want, "HE 三元组不自洽:Σa·Σb ≠ Σc");
// 单方分片不该泄露真值
assert_ne!(&a[..len], &ra[..], "单方 a 分片等于真值");
}
#[test]
fn he_mul_triple_three_parties() {
let n = 3;
let len = 4;
let master = [7u8; 32];
let mut a = vec![0u64; n * len];
let mut b = vec![0u64; n * len];
let mut c = vec![0u64; n * len];
triple::mul_triple_into(n, len, &master, 256, &mut a, &mut b, &mut c).unwrap();
let (mut ra, mut rb, mut rc) = (vec![0u64; len], vec![0u64; len], vec![0u64; len]);
share::reconstruct_into(&a, n, len, &mut ra).unwrap();
share::reconstruct_into(&b, n, len, &mut rb).unwrap();
share::reconstruct_into(&c, n, len, &mut rc).unwrap();
let mut want = vec![0u64; len];
ring::mul_into(&ra, &rb, &mut want).unwrap();
assert_eq!(rc, want, "三方 HE 三元组不自洽");
}
#[test]
fn he_matmul_triple_consistent() {
let n = 2;
let (rows, k, cols) = (2, 3, 2);
let master = [9u8; 32];
let (a_len, b_len, c_len) = (rows * k, k * cols, rows * cols);
let mut a = vec![0u64; n * a_len];
let mut b = vec![0u64; n * b_len];
let mut c = vec![0u64; n * c_len];
triple::matmul_triple_into(n, rows, k, cols, &master, 256, &mut a, &mut b, &mut c).unwrap();
let (mut ra, mut rb, mut rc) = (vec![0u64; a_len], vec![0u64; b_len], vec![0u64; c_len]);
share::reconstruct_into(&a, n, a_len, &mut ra).unwrap();
share::reconstruct_into(&b, n, b_len, &mut rb).unwrap();
share::reconstruct_into(&c, n, c_len, &mut rc).unwrap();
let mut want = vec![0u64; c_len];
ring::matmul_into(rows, k, cols, &ra, &rb, &mut want).unwrap();
assert_eq!(rc, want, "HE 矩阵三元组不自洽");
}
#[test]
fn he_triple_is_deterministic_given_master() {
let master = [13u8; 32];
let len = 4;
let mut a1 = vec![0u64; 2 * len];
let mut b1 = vec![0u64; 2 * len];
let mut c1 = vec![0u64; 2 * len];
let mut a2 = vec![0u64; 2 * len];
let mut b2 = vec![0u64; 2 * len];
let mut c2 = vec![0u64; 2 * len];
triple::mul_triple_into(2, len, &master, 256, &mut a1, &mut b1, &mut c1).unwrap();
triple::mul_triple_into(2, len, &master, 256, &mut a2, &mut b2, &mut c2).unwrap();
assert_eq!(a1, a2);
assert_eq!(b1, b2);
assert_eq!(c1, c2);
}
#[test]
fn pir_query_returns_target_item() {
let kp = quick_kp(11);
let mut s = stream(12);
let items = [1.5f64, -2.25, 0.0, 100.0, 3.14159];
for idx in 0..items.len() {
let q = pir::client_query(&kp.public, idx, items.len(), &mut s).unwrap();
let answer = pir::server_answer(&kp.public, &items, &q, &mut s).unwrap();
let got = pir::client_recover(&kp.private, &answer);
assert!((got - items[idx]).abs() < 1e-6, "PIR idx={idx}: got {got}, want {}", items[idx]);
}
}
#[test]
fn pir_wrong_index_returns_zero() {
// 单位向量查询下标 i,只应命中 items[i];空槽 = 0
let kp = quick_kp(13);
let mut s = stream(14);
let items = [10.0f64, 20.0, 30.0];
let q = pir::client_query(&kp.public, 1, 3, &mut s).unwrap();
let answer = pir::server_answer(&kp.public, &items, &q, &mut s).unwrap();
let got = pir::client_recover(&kp.private, &answer);
assert!((got - 20.0).abs() < 1e-6, "got {got}");
}
#[test]
fn encrypt_negative_matches_python_mod_semantics() {
// encrypt(-t) 与 encrypt(n - t) 必须同分布同语义(给定同一 r 时同密文)
let kp = quick_kp(15);
let n = kp.public.n.clone();
let r = BigUint::from_u64(99991);
let mut s = stream(16);
let c_neg = kp
.public
.encrypt_signed(&Signed { neg: true, mag: BigUint::from_u64(5) }, Some(&r), &mut s)
.unwrap();
let n_minus_5 = n.sub(&BigUint::from_u64(5));
let c_pos = kp.public.encrypt(&n_minus_5, Some(&r), &mut s).unwrap();
assert_eq!(c_neg, c_pos, "encrypt(-5) 必须等于 encrypt(n-5)(同一 r)");
}
#[test]
fn decrypt_signed_boundary_at_half() {
// 恰好 n//2 保持非负;n//2 + 1 映射为负(与 Python `>` 严格一致)
let kp = quick_kp(17);
let n = kp.public.n.clone();
let half = n.shr(1);
let mut s = stream(18);
let r = BigUint::from_u64(3);
let c1 = kp.public.encrypt(&half, Some(&r), &mut s).unwrap();
let s1 = kp.private.decrypt_signed(&c1);
assert!(!s1.neg && s1.mag == half, "n//2 应保持非负");
let c2 = kp.public.encrypt(&half.add(&BigUint::one()), Some(&r), &mut s).unwrap();
let s2 = kp.private.decrypt_signed(&c2);
assert!(s2.neg, "n//2 + 1 应映射为负");
assert_eq!(s2.mag, n.sub(&half.add(&BigUint::one())));
}
#[test]
fn keygen_rejects_bad_inputs() {
assert!(PublicKey::new(BigUint::from_u64(2)).is_err(), "偶数 n 必须拒绝");
assert!(PublicKey::new(BigUint::from_u64(3)).is_err(), "n < 4 必须拒绝");
assert!(PublicKey::new(BigUint::from_u64(15)).is_ok(), "3×5 数学上合法");
}
/// 位数太小必须**返回错误**,而不是 panic。
///
/// 改造前这里是 `assert!(bits >= 16)` —— 库函数不该因为调用方传了个小数字
/// 就把进程打挂;在 TEE 里 panic 直接等于 TA 崩溃。
#[test]
fn keygen_small_bits_is_an_error_not_a_panic() {
for bits in [0usize, 1, 8, 15] {
let r = paillier::keygen(bits, &mut stream(1));
assert!(
matches!(r, Err(paillier::HeError::KeyTooSmall)),
"bits={bits} 应返回 KeyTooSmall,实际 {r:?}"
);
}
}
/// 生产入口:自己取 OS 熵,两次调用必须得到不同密钥。
#[test]
fn keygen_os_uses_real_entropy() {
let a = paillier::keygen_os(256).expect("keygen_os");
let b = paillier::keygen_os(256).expect("keygen_os");
assert_ne!(a.public.n, b.public.n, "两次 keygen_os 得到同一个模数");
// 而且新密钥真的能用
let m = BigUint::from_u64(12345);
let c = a.public.encrypt(&m, None, &mut stream(7)).expect("加密");
assert_eq!(a.private.decrypt(&c), m);
}