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
274 lines
10 KiB
Rust
274 lines
10 KiB
Rust
//! 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);
|
||
}
|