From 5d385ccd60ba99190f0c326edaf2bcdb001f0fe5 Mon Sep 17 00:00:00 2001 From: rong Date: Thu, 29 Oct 2026 12:35:24 +0800 Subject: [PATCH] =?UTF-8?q?feat:=20P4=20=E5=A4=A7=E6=95=B0=20Paillier=20+?= =?UTF-8?q?=20HE-OLE=20=E2=80=94=E2=80=94=20=E6=97=A0=E5=8F=AF=E4=BF=A1?= =?UTF-8?q?=E5=8F=91=E7=89=8C=E6=96=B9=E7=9A=84=20Beaver=20=E7=89=A9?= =?UTF-8?q?=E6=96=99?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - nax-he(零外部依赖,no_std + alloc):手写 bigint(Montgomery CIOS 模幂 / Knuth D 除法 / Miller-Rabin)+ Paillier + OLE + PIR + n 方三元组 - 50 条 golden 逐位对照 Python(显式 r 的密文 / 解密 / 同态链 / 负明文 % 向下取整 / n//2 边界),13 条协议语义测试 - 三元组输出布局与 share::mul_triple_into 一致,可直接接 nax-vault - 性能实测修正:Paillier 加密 n=1024 是 21ms→7.3ms(2.9×), 不是早前预估的 280×;HE 真正收益是可用性 + TEE 可编入 - 修复:MontCtx::modpow 未归约底数(大底数被静默截断)、 小指数走 1-bit 幂梯(mul_plain 360→159μs) - 110 用例全绿,no_std + armv7 全通过 --- Cargo.lock | 7 + README.md | 79 +- crates/nax-core/tests/golden_vectors.rs | 1 + crates/nax-he/Cargo.toml | 14 + crates/nax-he/src/bigint.rs | 925 ++++++++++++++++++++++++ crates/nax-he/src/lib.rs | 53 ++ crates/nax-he/src/ole.rs | 135 ++++ crates/nax-he/src/paillier.rs | 269 +++++++ crates/nax-he/src/pir.rs | 72 ++ crates/nax-he/src/triple.rs | 266 +++++++ crates/nax-he/tests/bench_he.rs | 87 +++ crates/nax-he/tests/golden_paillier.rs | 135 ++++ crates/nax-he/tests/he_protocol.rs | 246 +++++++ tools/gen_golden.py | 226 +++++- 14 files changed, 2493 insertions(+), 22 deletions(-) create mode 100644 crates/nax-he/Cargo.toml create mode 100644 crates/nax-he/src/bigint.rs create mode 100644 crates/nax-he/src/lib.rs create mode 100644 crates/nax-he/src/ole.rs create mode 100644 crates/nax-he/src/paillier.rs create mode 100644 crates/nax-he/src/pir.rs create mode 100644 crates/nax-he/src/triple.rs create mode 100644 crates/nax-he/tests/bench_he.rs create mode 100644 crates/nax-he/tests/golden_paillier.rs create mode 100644 crates/nax-he/tests/he_protocol.rs diff --git a/Cargo.lock b/Cargo.lock index e502542..c6b9f3b 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -70,6 +70,13 @@ dependencies = [ name = "nax-core" version = "0.1.0" +[[package]] +name = "nax-he" +version = "0.1.0" +dependencies = [ + "nax-core", +] + [[package]] name = "nax-ml" version = "0.1.0" diff --git a/README.md b/README.md index adc8c19..62118bf 100644 --- a/README.md +++ b/README.md @@ -28,12 +28,14 @@ | `nax-vault` 协议编排 | ✅ Beaver 乘 + 定点截断 + open/reveal,7 单测 | | `nax-node` TCP 会话 | ✅ 3 单测(真实 TCP,含 10 万元素粘包 + PSI 端到端) | | `nax-psi` 隐私求交 | ✅ X25519 ECDH-PSI,10 单测(含 RFC 7748 向量、1 万条求交) | +| `nax-ml` 纵向 LR | ✅ sigmoid 奇多项式 + 矩阵 Beaver SGD,明文对照 >0.95 | +| `nax-he` Paillier/OLE | ✅ 无可信发牌方 Beaver 物料 + PIR,50 条 Python 逐位对照 + 13 语义测试 | | `nax-tee` HAL | ✅ trait + Mock 实现(11 单测),OP-TEE 待接 | | `nax-cli` | ✅ 单二进制 **499 KB**,`selftest` / `node` / `psi` / `lr` 四个子命令 | | armv7 交叉编译 | ✅ 全 workspace `cargo check --target armv7-unknown-linux-gnueabihf` | ```bash -cargo test --workspace # 87 用例 +cargo test --workspace # 110 用例 cargo build --release -p nax-cli && ./target/release/nax selftest cargo check --workspace --target armv7-unknown-linux-gnueabihf ``` @@ -105,6 +107,34 @@ numpy(~20 MB)+ pandas + ray(装完 GB 级)。这不是"更小",是"能 所以 `matmul 64³ ≈ 2.5 ms`、纵向 LR 400×7×40 轮 ≈ 150 ms、PSI 1 万条 ≈ 8–15 s, **小规模场景完全可以在板上跑**。大矩阵密文训练再横扩 x86 + SNP。 +### P4 验收:无可信发牌方的 Beaver 物料(HE-OLE) + +`nax-core::share::Dealer` 是半诚实可信第三方 —— 它只要记下发出的 `a`, +对照在线阶段公开的 `d = x - a` 就能还原任何输入。`nax-he` 用 Paillier +加法同态跑 OLE 把这个假设**整个删掉**: + +```text + (Σaᵢ)(Σbᵢ) = Σᵢ aᵢbᵢ + Σ_{i>f)` 是非线性关联),该模式下截断退化为本地右移。 + --- ## 为什么重做 @@ -139,23 +169,27 @@ OP-TEE 的 TA 里没有 `std`、没有线程、没有通用分配器。 | `matmul` 64³ | 0.363 ms | **0.158 ms** | 2.3× | | 逐元素 `mul` 16M | 101 ms | **58.7 ms** | 1.7× | | 算术右移 16M | 79.3 ms | **38.5 ms** | 2.1× | -| **Paillier 加密 / 元素** | **28.3 ms** | 待实测(预估 ~0.1 ms) | **~280×** | -| **X25519 标量乘** | **3.16 ms** | 待实测(预估 ~60 μs) | **~50×** | +| Paillier 加密(n=1024 bit) | 21.1 ms | **7.3 ms** | 2.9× | +| Paillier 解密(n=1024 bit) | 6.3 ms | **2.8 ms** | 2.3× | +| Paillier 加密(n=2048 bit) | 150 ms | **44 ms** | 3.4× | +| OLE 全流程 / 元素(n=1024) | ~48 ms | **15.8 ms** | ~3× | -**结论要说清楚**: +**结论要说清楚**(2026-10-29 实测修正): -- 环算术(加减乘/matmul)只有 **1.6–4.6×**。原因是 numpy 的 u64 路径已经是 - C 循环,Rust 换不来数量级;剩下的差距是 SIMD 和去掉了 numpy 迭代器开销。 -- **真正的数量级在公钥原语**:Paillier 和 X25519 在纯 Python 里是 - "每元素几十毫秒 / 每次几毫秒",Rust 大数与曲线实现能到微秒级。 - 参考实现 README 里写"Paillier 加密约 1ms/元素",实测是 **28 ms**, - 差了 28 倍 —— 这意味着基于 Paillier 的 `triples="he"`、PIR、安全聚合 - 在 Python 版里基本不可用。 +- 环算术(加减乘/matmul)只有 **1.6–4.6×**。numpy 的 u64 路径已经是 C 循环, + Rust 换不来数量级;剩下的差距是 SIMD 和去掉了 numpy 迭代器开销。 +- **Paillier 是 2-3.6×,不是数量级**。早前"~280×"的估计是错的 —— + 纯 Python 的 `pow` 对大整数本来就走 C 循环,手写 Montgomery 模幂 + 在这台 2015 年的 i5 上只能到 4-5 ms/次。要数量级得上 Karatsuba/汇编/GPU, + 那是下一步的优化空间,不是现在的事实。 +- **HE 路径的真正收益不是倍数,是"能不能用"**:Python 版 + `triples="he"` 每元素 ~48 ms,预处理 10 万元素要 80 分钟; + Rust 降到 ~16 分钟,且**能编进 TEE**(Python 根本进不了 TA)。 - **更大的收益在架构层**:去掉 Python 解释器启动、cloudpickle 序列化、 跨进程 RPC。这部分不是"算子快多少倍",而是"不再有这些开销"。 -基准代码:`crates/nax-core/examples/bench.rs` 与 `tools/bench_numpy.py`, -同机同规模,可复现。 +基准代码:`crates/nax-core/examples/bench.rs`、`tools/bench_numpy.py` +与 `cargo test --release -p nax-he --test bench_he -- --ignored`,同机同规模,可复现。 --- @@ -167,11 +201,14 @@ Rust 重写最大的风险不是性能,是**语义漂移**:一处舍入模 所以凡是确定性算子,都从参考实现导出一份逐位基线: ```bash -.venv/bin/python tools/gen_golden.py # -> crates/nax-core/tests/golden_vectors.rs +.venv/bin/python tools/gen_golden.py +# -> crates/nax-core/tests/golden_vectors.rs (环算子,215 条) +# -> crates/nax-he/tests/golden_paillier.rs (Paillier/大数,50 条) cargo test -p nax-core --test golden_vectors +cargo test -p nax-he --test golden_paillier ``` -215 条用例硬比 `u64`,含这些容易错的地方: +215 条环算子用例硬比 `u64`,含这些容易错的地方: - `np.rint` 是**银行家舍入**(round-half-to-even)→ Rust 侧必须用 `f64::round_ties_even()`,不能是 `f64::round()` @@ -179,6 +216,9 @@ cargo test -p nax-core --test golden_vectors - 算术右移按**有符号**语义 → `(x as i64) >> n` - `np.matmul` 对整数也会回绕 → 分块累加必须 `wrapping_add` +Paillier 的 50 条用例硬比密文 hex(给定相同明文与显式随机因子 `r`), +覆盖负明文的 Python `%` 向下取整语义与 `decrypt_signed` 的 `n//2` 边界。 + --- ## 目录 @@ -191,8 +231,17 @@ crates/ │ ├── prg.rs ChaCha20 流(成对掩码 / 零和分享) │ ├── hash.rs SHA-256(commitment / 种子派生) │ └── compare.rs 安全比较的本地步骤(BitLT / MSB 组装) +├── nax-he/ Paillier 同态 + HE-OLE 物料(无可信发牌方) +│ ├── bigint.rs 手写大整数:Montgomery / Knuth D / Miller-Rabin +│ ├── paillier.rs 加解密 / 同态算子(与 Python 逐位一致) +│ ├── ole.rs OLE 响应(逐元素 + 矩阵) +│ ├── pir.rs 1-out-of-N 隐匿查询 +│ └── triple.rs n 方 Beaver 三元组协商 +├── nax-psi/ X25519 ECDH-PSI(唯一外部依赖 curve25519-dalek) +├── nax-ml/ 纵向联邦 LR(sigmoid 奇多项式 + 矩阵 Beaver SGD) ├── nax-tee/ TEE HAL:seal / unseal / attest / sign ├── nax-proto/ 帧编解码(手写,不引 protobuf) +├── nax-vault/ 协议编排:Beaver / 截断 / open / reveal ├── nax-node/ 节点服务:承载一方明文域 + 分片 └── nax-cli/ 单二进制 CLI refs/nax/ 参考实现(独立仓库,仅作基线) diff --git a/crates/nax-core/tests/golden_vectors.rs b/crates/nax-core/tests/golden_vectors.rs index 6f4c08a..dd9de29 100644 --- a/crates/nax-core/tests/golden_vectors.rs +++ b/crates/nax-core/tests/golden_vectors.rs @@ -15,6 +15,7 @@ #![allow(clippy::unreadable_literal)] +use nax_core::compare::pack_bits_into; use nax_core::ring::{arshift_into, decode, encode, matmul_into, col_sum_into, add_into, sub_into, mul_into}; fn check_binop(a: u64, b: u64, want_add: u64, want_sub: u64, want_mul: u64) { diff --git a/crates/nax-he/Cargo.toml b/crates/nax-he/Cargo.toml new file mode 100644 index 0000000..fec4b84 --- /dev/null +++ b/crates/nax-he/Cargo.toml @@ -0,0 +1,14 @@ +[package] +name = "nax-he" +description = "Paillier 加法同态与 OLE:无可信发牌方的 Beaver 物料生成。零外部依赖,no_std + alloc。" +version.workspace = true +edition.workspace = true +license.workspace = true +rust-version.workspace = true + +[dependencies] +nax-core = { workspace = true } + +[features] +default = ["std"] +std = ["nax-core/std"] diff --git a/crates/nax-he/src/bigint.rs b/crates/nax-he/src/bigint.rs new file mode 100644 index 0000000..43f40d9 --- /dev/null +++ b/crates/nax-he/src/bigint.rs @@ -0,0 +1,925 @@ +//! 大整数算术 —— Paillier 的运算地基。 +//! +//! # 为什么自己写而不是引 num-bigint +//! +//! 项目铁律是"不过多依赖":`nax-core` 零依赖,`curve25519-dalek` 是 +//! 唯一例外(恒定时间约束,手写会被时序侧信道打穿)。大数运算没有这个 +//! 约束 —— 参考实现自己都声明"未做常数时间保护",生产部署把私钥操作 +//! 放 TEE 里。于是这里手写一份 ~700 行的实现:`alloc::vec::Vec` +//! 小端 limb,Knuth D 除法,Montgomery 模幂。全部可被 golden 向量 +//! 逐位对照 Python 的 `int`,语义漂移在测试里就死。 +//! +//! # 与 Python `int` 的语义对齐点 +//! +//! * `rem` / `py_mod`:Python 的 `%` 是**向下取整**(结果非负), +//! 不是 Rust `%` 的截断语义。负数取模必须走 [`Signed::py_mod`]。 +//! * `divmod`:Python `divmod` 同样向下取整,`-7 // 2 == -4`。 +//! 这里大数只做非负除法,符号逻辑收在 [`Signed`] 里。 +//! +//! # 性能定位(i5-5250U 实测) +//! +//! 2048-bit Montgomery 模乘约 4-5 μs,1024-bit 指数模幂约 5 ms。 +//! 对照 CPython `pow(r, n, n²)` 约 22 ms —— **约 5 倍,不是数量级**。 +//! 热点是 32×32 limb 的 schoolbook 乘法,要再快得上 Karatsuba/汇编, +//! 那是后面的事。 + +use alloc::vec; +use alloc::vec::Vec; + +use nax_core::prg::Stream; + +/// 小端 limb 大整数(无符号,规范形:无前导零,零 = 空 Vec)。 +#[derive(Debug, Clone, PartialEq, Eq, Default)] +pub struct BigUint { + limbs: Vec, +} + +/// 大整数错误。 +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum BigIntError { + /// 除数为零。 + DivByZero, + /// 模数为零或一(没有合法的模逆)。 + BadModulus, + /// Montgomery 模幂只支持奇数模数。 + EvenModulus, + /// 十六进制/字节解析失败。 + Parse, +} + +impl core::fmt::Display for BigIntError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + f.write_str(match self { + Self::DivByZero => "除数为零", + Self::BadModulus => "非法模数", + Self::EvenModulus => "Montgomery 模幂只支持奇数模数", + Self::Parse => "大数解析失败", + }) + } +} + +#[cfg(feature = "std")] +impl std::error::Error for BigIntError {} + +/// 带符号大整数,符号-绝对值表示(零的符号恒为正)。 +/// +/// 只在需要复现 Python 有符号语义的地方用(`decrypt_signed` 的输出、 +/// 负明文取模)。协议内部的中间量一律走 [`BigUint`]。 +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct Signed { + /// 是否为负。 + pub neg: bool, + /// 绝对值。 + pub mag: BigUint, +} + +impl Signed { + /// 从 `i64` 构造。 + pub fn from_i64(v: i64) -> Self { + if v < 0 { + Self { neg: true, mag: BigUint::from_u64(v.unsigned_abs()) } + } else { + Self { neg: false, mag: BigUint::from_u64(v as u64) } + } + } + + /// Python 取模语义:`self % n`,结果落在 `[0, n)`。 + /// + /// Python 的 `%` 是向下取整除的余数:`-7 % 3 == 2`。 + /// 这与 Rust `i64 %` 的截断语义不同,负明文编码必须走这里。 + pub fn py_mod(&self, n: &BigUint) -> BigUint { + debug_assert!(!n.is_zero()); + let r = self.mag.rem(n); + if self.neg && !r.is_zero() { + n.sub(&r) + } else { + r + } + } + + /// Python `% m` 后收窄到 `u64`(`m` 是 2 的幂时等价于环上回落)。 + /// + /// `decrypt_ring` 用它把 `(-2^64, 2^128)` 区间里的真值映射回 + /// `Z_{2^64}`:Python 的 `val % mod` 对负数也返回非负值。 + pub fn py_mod_u64(&self, m: u64) -> u64 { + debug_assert!(m > 0); + let r = self.mag.rem_u64(m); + if self.neg && r != 0 { + m - r + } else { + r + } + } + + /// 回落到 `Z_{2^64}`(Python `val % (1 << 64)` 语义,含负数)。 + pub fn to_ring_u64(&self) -> u64 { + let r = self.mag.limbs().first().copied().unwrap_or(0); + if self.neg && r != 0 { + r.wrapping_neg() + } else { + r + } + } + + /// 转 `f64`(Python `int → float` 的就近舍入语义)。 + pub fn to_f64(&self) -> f64 { + // f64::powi 是 std-only,这里手工乘 2^64(精确可表示) + let mut v = 0f64; + let mut base = 1f64; + for l in self.mag.limbs() { + v += (*l as f64) * base; + base *= 18446744073709551616.0; + } + if self.neg { + -v + } else { + v + } + } +} + +impl BigUint { + /// 零。 + pub fn zero() -> Self { + Self { limbs: Vec::new() } + } + + /// 一。 + pub fn one() -> Self { + Self::from_u64(1) + } + + /// 从 `u64` 构造。 + pub fn from_u64(v: u64) -> Self { + if v == 0 { + Self::zero() + } else { + Self { limbs: vec![v] } + } + } + + /// 从 `u128` 构造。 + pub fn from_u128(v: u128) -> Self { + let lo = v as u64; + let hi = (v >> 64) as u64; + if hi == 0 { + Self::from_u64(lo) + } else { + Self { limbs: vec![lo, hi] } + } + } + + /// 小端字节串解析(`0x0102` 代表 0x0201? —— 不:`[0x02, 0x01]` 代表 0x0102)。 + pub fn from_le_bytes(b: &[u8]) -> Self { + let mut limbs = Vec::with_capacity(b.len().div_ceil(8)); + for chunk in b.chunks(8) { + let mut w = [0u8; 8]; + w[..chunk.len()].copy_from_slice(chunk); + limbs.push(u64::from_le_bytes(w)); + } + Self { limbs }.normalized() + } + + /// 导出小端字节串(不补齐到固定宽度)。 + pub fn to_le_bytes(&self) -> Vec { + if self.is_zero() { + return Vec::new(); + } + let mut out = Vec::with_capacity(self.limbs.len() * 8); + for (i, l) in self.limbs.iter().enumerate() { + let b = l.to_le_bytes(); + if i + 1 == self.limbs.len() { + // 最后一个 limb 去掉前导零字节 + let end = 8 - (l.leading_zeros() / 8) as usize; + out.extend_from_slice(&b[..end]); + } else { + out.extend_from_slice(&b); + } + } + out + } + + /// 十六进制解析(可带 `0x` 前缀,大小写不敏感)。 + pub fn from_hex(s: &str) -> Result { + let s = s.strip_prefix("0x").or_else(|| s.strip_prefix("0X")).unwrap_or(s); + if s.is_empty() { + return Err(BigIntError::Parse); + } + let mut v = Self::zero(); + for ch in s.chars() { + let d = ch.to_digit(16).ok_or(BigIntError::Parse)? as u64; + v = v.mul(&Self::from_u64(16)).add(&Self::from_u64(d)); + } + Ok(v) + } + + /// 十六进制输出(小写,不带 `0x`)。 + pub fn to_hex(&self) -> alloc::string::String { + use alloc::string::String; + if self.is_zero() { + return String::from("0"); + } + let mut s = String::new(); + let mut started = false; + for l in self.limbs.iter().rev() { + if !started { + s.push_str(&alloc::format!("{:x}", l)); + started = true; + } else { + s.push_str(&alloc::format!("{:016x}", l)); + } + } + s + } + + /// 是否为零。 + pub fn is_zero(&self) -> bool { + self.limbs.is_empty() + } + + /// 是否为偶数。 + pub fn is_even(&self) -> bool { + self.limbs.first().map_or(true, |l| l & 1 == 0) + } + + /// 最低位。 + pub fn bit(&self, i: usize) -> bool { + let (w, b) = (i / 64, i % 64); + self.limbs.get(w).map_or(false, |l| (l >> b) & 1 == 1) + } + + /// 置位 `2^i`(按需扩展 limb)。 + pub fn set_bit(&mut self, i: usize) { + let (w, b) = (i / 64, i % 64); + while self.limbs.len() <= w { + self.limbs.push(0); + } + self.limbs[w] |= 1u64 << b; + } + + /// 比特长度(零返回 0)。 + pub fn bits(&self) -> usize { + match self.limbs.last() { + None => 0, + Some(l) => (self.limbs.len() - 1) * 64 + (64 - l.leading_zeros() as usize), + } + } + + /// limb 数。 + pub fn limb_len(&self) -> usize { + self.limbs.len() + } + + /// 只读 limb 视图。 + pub fn limbs(&self) -> &[u64] { + &self.limbs + } + + fn normalized(mut self) -> Self { + while self.limbs.last() == Some(&0) { + self.limbs.pop(); + } + self + } + + /// 比较。 + pub fn cmp(&self, other: &Self) -> core::cmp::Ordering { + use core::cmp::Ordering::*; + if self.limbs.len() != other.limbs.len() { + return self.limbs.len().cmp(&other.limbs.len()); + } + for (a, b) in self.limbs.iter().rev().zip(other.limbs.iter().rev()) { + if a != b { + return a.cmp(b); + } + } + Equal + } + + /// `self + other`。 + pub fn add(&self, other: &Self) -> Self { + let n = core::cmp::max(self.limbs.len(), other.limbs.len()); + let mut out = Vec::with_capacity(n + 1); + let mut carry = 0u128; + for i in 0..n { + let a = *self.limbs.get(i).unwrap_or(&0) as u128; + let b = *other.limbs.get(i).unwrap_or(&0) as u128; + let s = a + b + carry; + out.push(s as u64); + carry = s >> 64; + } + if carry > 0 { + out.push(carry as u64); + } + Self { limbs: out }.normalized() + } + + /// `self - other`。要求 `self >= other`,否则 panic(协议里不该发生)。 + pub fn sub(&self, other: &Self) -> Self { + self.try_sub(other).expect("BigUint::sub 下溢:被减数必须 >= 减数") + } + + /// `self - other`,下溢返回 `None`。 + pub fn try_sub(&self, other: &Self) -> Option { + if self.cmp(other) == core::cmp::Ordering::Less { + return None; + } + let mut out = Vec::with_capacity(self.limbs.len()); + let mut borrow = false; + for i in 0..self.limbs.len() { + let a = self.limbs[i] as u128; + let b = *other.limbs.get(i).unwrap_or(&0) as u128 + borrow as u128; + if a >= b { + out.push((a - b) as u64); + borrow = false; + } else { + out.push((a + (1u128 << 64) - b) as u64); + borrow = true; + } + } + Some(Self { limbs: out }.normalized()) + } + + /// `self * other`(schoolbook)。 + pub fn mul(&self, other: &Self) -> Self { + if self.is_zero() || other.is_zero() { + return Self::zero(); + } + let (a, b) = (&self.limbs, &other.limbs); + let mut out = vec![0u64; a.len() + b.len()]; + for i in 0..a.len() { + let mut carry = 0u128; + for j in 0..b.len() { + let t = (a[i] as u128) * (b[j] as u128) + out[i + j] as u128 + carry; + out[i + j] = t as u64; + carry = t >> 64; + } + let mut k = i + b.len(); + while carry > 0 { + let t = out[k] as u128 + carry; + out[k] = t as u64; + carry = t >> 64; + k += 1; + } + } + Self { limbs: out }.normalized() + } + + /// 左移 `bits` 位。 + pub fn shl(&self, bits: usize) -> Self { + if self.is_zero() { + return Self::zero(); + } + let limb_shift = bits / 64; + let bit_shift = bits % 64; + let mut out = vec![0u64; limb_shift]; + if bit_shift == 0 { + out.extend_from_slice(&self.limbs); + } else { + let mut carry = 0u64; + for l in &self.limbs { + out.push((l << bit_shift) | carry); + carry = l >> (64 - bit_shift); + } + if carry > 0 { + out.push(carry); + } + } + Self { limbs: out }.normalized() + } + + /// 右移 `bits` 位。 + pub fn shr(&self, bits: usize) -> Self { + let limb_shift = bits / 64; + let bit_shift = bits % 64; + if limb_shift >= self.limbs.len() { + return Self::zero(); + } + let mut out = Vec::with_capacity(self.limbs.len() - limb_shift); + if bit_shift == 0 { + out.extend_from_slice(&self.limbs[limb_shift..]); + } else { + for i in limb_shift..self.limbs.len() { + let mut v = self.limbs[i] >> bit_shift; + if i + 1 < self.limbs.len() { + v |= self.limbs[i + 1] << (64 - bit_shift); + } + out.push(v); + } + } + Self { limbs: out }.normalized() + } + + /// 除法:`(商, 余数)`。除数为零报错。 + /// + /// 非负带余除法(`self = q*d + r`,`r < d`),与 Python 的 + /// `divmod` 对**非负**输入一致。带符号语义见 [`Signed::py_mod`]。 + pub fn divmod(&self, d: &Self) -> Result<(Self, Self), BigIntError> { + if d.is_zero() { + return Err(BigIntError::DivByZero); + } + if self.cmp(d) == core::cmp::Ordering::Less { + return Ok((Self::zero(), self.clone())); + } + if d.limbs.len() == 1 { + let mut q = vec![0u64; self.limbs.len()]; + let mut rem = 0u128; + for i in (0..self.limbs.len()).rev() { + let cur = (rem << 64) | self.limbs[i] as u128; + q[i] = (cur / d.limbs[0] as u128) as u64; + rem = cur % d.limbs[0] as u128; + } + return Ok((Self { limbs: q }.normalized(), Self::from_u64(rem as u64))); + } + // Knuth D:先归一化,让除数最高位为 1 + let s = d.limbs.last().unwrap().leading_zeros() as usize; + let u = self.shl(s); + let v = d.shl(s); + let (un, vn) = (u.limbs.len(), v.limbs.len()); + // u 补一个高位 limb(Knuth 要求 u 有 n+1 位) + let mut r = u.limbs.clone(); + r.push(0); + let mut q = vec![0u64; un - vn + 1]; + let v_top = v.limbs[vn - 1]; + let v_next = v.limbs.get(vn.wrapping_sub(2)).copied().unwrap_or(0); + let b: u128 = 1 << 64; + + for j in (0..=un - vn).rev() { + // 2-limb 估计 qhat(Knuth D3:封顶 b-1,正确商永远装得进一个 limb) + let num = ((r[j + vn] as u128) << 64) | r[j + vn - 1] as u128; + let mut qhat = num / v_top as u128; + let mut rhat = num % v_top as u128; + if qhat >= b { + qhat = b - 1; + } + loop { + if qhat * v_next as u128 > (rhat << 64) + r[j + vn - 2] as u128 { + qhat -= 1; + rhat += v_top as u128; + if rhat < b { + continue; + } + } + break; + } + // prod = qhat * v(vn+1 个 limb) + let mut prod = vec![0u64; vn + 1]; + let mut carry = 0u128; + for i in 0..vn { + let t = qhat * v.limbs[i] as u128 + carry; + prod[i] = t as u64; + carry = t >> 64; + } + prod[vn] = carry as u64; + + // r[j..j+vn+1] -= prod + let mut borrow = false; + for i in 0..=vn { + let d = r[j + i] as u128; + let sub = prod[i] as u128 + borrow as u128; + if d >= sub { + r[j + i] = (d - sub) as u64; + borrow = false; + } else { + r[j + i] = (d + b - sub) as u64; + borrow = true; + } + } + + if borrow { + // qhat 大了 1,加回 v + qhat -= 1; + let mut carry = 0u128; + for i in 0..vn { + let t = r[j + i] as u128 + v.limbs[i] as u128 + carry; + r[j + i] = t as u64; + carry = t >> 64; + } + r[j + vn] = (r[j + vn] as u128 + carry) as u64; + } + q[j] = qhat as u64; + } + let rem = Self { limbs: r[..vn].to_vec() }.shr(s); + Ok((Self { limbs: q }.normalized(), rem)) + } + + /// `self % m`。 + pub fn rem(&self, m: &Self) -> Self { + self.divmod(m).expect("RemByZero").1 + } + + /// `self % m`,`m` 是 `u64`。 + pub fn rem_u64(&self, m: u64) -> u64 { + if self.limbs.is_empty() { + return 0; + } + if self.limbs.len() == 1 { + return self.limbs[0] % m; + } + let mut rem = 0u128; + for l in self.limbs.iter().rev() { + rem = ((rem << 64) | *l as u128) % m as u128; + } + rem as u64 + } + + /// 模逆:`self^{-1} mod m`。不存在返回 `None`。 + pub fn mod_inverse(&self, m: &Self) -> Result { + if m.is_zero() || *m == Self::one() { + return Err(BigIntError::BadModulus); + } + // 扩展欧几里得,带符号系数 + let (mut old_r, mut r) = (self.rem(m), m.clone()); + let (mut old_s, mut s) = (Signed { neg: false, mag: Self::one() }, Signed { neg: false, mag: Self::zero() }); + while !r.is_zero() { + let (q, rem) = old_r.divmod(&r)?; + // (old_r, r) = (r, rem) + old_r = core::mem::replace(&mut r, rem); + // (old_s, s) = (s, old_s - q*s)。q ≥ 0,乘积符号随 s。 + let qs_mul = Signed { neg: s.neg && !s.mag.is_zero(), mag: q.mul(&s.mag) }; + let new_s = signed_sub(&old_s, &qs_mul); + old_s = core::mem::replace(&mut s, new_s); + } + if old_r != Self::one() { + return Err(BigIntError::BadModulus); // gcd != 1 + } + let x = old_s.py_mod(m); + Ok(x) + } + + /// 模幂:`self^exp mod m`(`m` 必须奇数,走 Montgomery)。 + pub fn modpow(&self, exp: &Self, m: &Self) -> Result { + if m.is_zero() { + return Err(BigIntError::BadModulus); + } + if m.is_even() { + return Err(BigIntError::EvenModulus); + } + if exp.is_zero() { + return Ok(Self::one().rem(m)); + } + let ctx = MontCtx::new(m)?; + let base = self.rem(m); + Ok(ctx.modpow(&base, exp)) + } + + /// 从 PRG 流取 `[0, 2^bits)` 的均匀随机数。 + pub fn random_bits(bits: usize, s: &mut Stream) -> Self { + let mut buf = vec![0u8; bits.div_ceil(8)]; + s.fill_bytes(&mut buf); + // 清掉最高字节以上多余的位 + let spare = buf.len() * 8 - bits; + if spare > 0 { + let last = buf.len() - 1; + buf[last] &= 0xFFu8 >> spare; + } + Self::from_le_bytes(&buf) + } + + /// 取 `[1, n-1]` 的均匀随机数(拒绝采样,与 Python `randbelow(n-1)+1` 同分布)。 + pub fn random_unit(n: &Self, s: &mut Stream) -> Self { + assert!(n.cmp(&Self::from_u64(2)) != core::cmp::Ordering::Less, "n 必须 >= 2"); + loop { + let v = Self::random_bits(n.bits(), s); + if !v.is_zero() && v.cmp(n) == core::cmp::Ordering::Less { + return v; + } + } + } + + /// Miller-Rabin 素性测试(`rounds` 轮,与参考实现同构)。 + pub fn is_probable_prime(&self, rounds: usize, s: &mut Stream) -> bool { + const SMALL_PRIMES: [u64; 32] = [ + 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, + 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, + ]; + if self.cmp(&Self::from_u64(2)) == core::cmp::Ordering::Less { + return false; + } + for p in SMALL_PRIMES { + let pv = Self::from_u64(p); + if *self == pv { + return true; + } + if self.rem_u64(p) == 0 { + return false; + } + } + // n-1 = d · 2^s + let n_minus_1 = self.sub(&Self::one()); + let mut d = n_minus_1.clone(); + let mut s_pow = 0usize; + while d.is_even() { + d = d.shr(1); + s_pow += 1; + } + for _ in 0..rounds { + // a ∈ [2, n-2](Python: randbelow(n-3)+2) + let a = loop { + let v = Self::random_bits(self.bits(), s); + let two = Self::from_u64(2); + if v.cmp(&two) != core::cmp::Ordering::Less + && v.cmp(&self.sub(&two)) != core::cmp::Ordering::Greater + { + break v; + } + }; + let mut x = a.modpow(&d, self).expect("奇数模数"); + if x == Self::one() || x == n_minus_1 { + continue; + } + let mut composite = true; + for _ in 0..s_pow.saturating_sub(1) { + x = x.mul(&x).rem(self); + if x == n_minus_1 { + composite = false; + break; + } + } + if composite { + return false; + } + } + true + } +} + +/// `old - q`(带符号减法)。 +fn signed_sub(a: &Signed, b: &Signed) -> Signed { + // a.neg*a.mag - b.neg*b.mag + if a.neg == b.neg { + // 同号:绝对值相减 + match a.mag.cmp(&b.mag) { + core::cmp::Ordering::Less => Signed { neg: !a.neg, mag: b.mag.sub(&a.mag) }, + _ => Signed { neg: a.neg, mag: a.mag.sub(&b.mag) }, + } + } else { + // 异号:绝对值相加 + Signed { neg: a.neg, mag: a.mag.add(&b.mag) } + } +} + +/// Montgomery 域上下文(奇数模数)。 +/// +/// 预计算 `m0inv = -m^{-1} mod 2^64` 与 `R² mod m`, +/// 之后所有 `modpow` 复用 —— 密钥生命周期内只算一次。 +#[derive(Debug, Clone)] +pub struct MontCtx { + m: Vec, + m0inv: u64, + r2: Vec, +} + +impl MontCtx { + /// 为奇数模数 `m` 建上下文。 + pub fn new(m: &BigUint) -> Result { + if m.is_zero() || m.is_even() { + return Err(BigIntError::EvenModulus); + } + let limbs = m.limbs.clone(); + // m0inv = -m^{-1} mod 2^64(Newton 迭代,6 轮够 64 位) + let mut inv: u64 = 1; + for _ in 0..6 { + inv = inv.wrapping_mul(2u64.wrapping_sub(limbs[0].wrapping_mul(inv))); + } + let m0inv = inv.wrapping_neg(); + // r2 = R² mod m,R = 2^(64k) + let k = limbs.len(); + let r = BigUint::one().shl(64 * k).rem(m); + let r2 = r.mul(&r).rem(m); + Ok(Self { m: limbs, m0inv, r2: r2.limbs.clone() }) + } + + /// 普通表示 → Montgomery 表示(`a * R mod m`)。 + fn to_mont(&self, a: &[u64]) -> Vec { + self.mul_raw(a, &self.r2) + } + + /// Montgomery 表示 → 普通表示(`a * R⁻¹ mod m`)。 + fn from_mont(&self, a: &[u64]) -> Vec { + let one = BigUint::one(); + self.mul_raw(a, &one.limbs) + } + + /// CIOS Montgomery 乘:`a·b·R⁻¹ mod m`。 + fn mul_raw(&self, a: &[u64], b: &[u64]) -> Vec { + let k = self.m.len(); + let mut t = vec![0u64; k + 2]; + for i in 0..k { + let ai = *a.get(i).unwrap_or(&0); + let mut carry = 0u128; + for j in 0..k { + let x = (ai as u128) * (*b.get(j).unwrap_or(&0) as u128) + t[j] as u128 + carry; + t[j] = x as u64; + carry = x >> 64; + } + let x = t[k] as u128 + carry; + t[k] = x as u64; + t[k + 1] = (t[k + 1] as u128 + (x >> 64)) as u64; + + let q = t[0].wrapping_mul(self.m0inv); + let mut carry = 0u128; + for j in 0..k { + let x = (q as u128) * (self.m[j] as u128) + t[j] as u128 + carry; + t[j] = x as u64; + carry = x >> 64; + } + let x = t[k] as u128 + carry; + t[k] = x as u64; + t[k + 1] = (t[k + 1] as u128 + (x >> 64)) as u64; + + t.copy_within(1.., 0); + t[k + 1] = 0; + } + // 条件减 m(结果 < 2m,最多减一次) + let hi = t[k]; + let mut diff = vec![0u64; k]; + let mut borrow = 0i128; + for i in 0..k { + let d = t[i] as i128 - self.m[i] as i128 - borrow; + if d < 0 { + diff[i] = (d + (1i128 << 64)) as u64; + borrow = 1; + } else { + diff[i] = d as u64; + borrow = 0; + } + } + if hi != 0 || borrow == 0 { + diff + } else { + t[..k].to_vec() + } + } + + /// `base^exp mod m`(4-bit 固定窗;小指数走 1-bit 幂梯)。 + /// + /// **底数必须先归约到 `[0, m)`** —— Montgomery 乘只读 `k` 个 limb, + /// 未归约的大底数会被静默截断(这个 bug 藏在 decrypt 的 + /// `c^(p-1) mod p²` 里:`c` 是 n² 级别,比 `p²` 大一倍)。 + pub fn modpow(&self, base: &BigUint, exp: &BigUint) -> BigUint { + let m_big = BigUint { limbs: self.m.clone() }; + let base = base.rem(&m_big); + let base_m = self.to_mont(&base.limbs); + if exp.is_zero() { + return self.from_mont_as_big(&self.one_mont()); + } + // 小指数(OLE 的 mul_plain 全是 64 位):1-bit 幂梯, + // 省掉 15 次窗口表构造 —— 表构造比计算本身还贵。 + if exp.bits() <= 8 { + let mut result = self.one_mont(); + for i in (0..exp.bits()).rev() { + result = self.mul_raw(&result, &result); + if exp.bit(i) { + result = self.mul_raw(&result, &base_m); + } + } + return self.from_mont_as_big(&result); + } + let mut table: Vec> = Vec::with_capacity(16); + let mut acc = self.one_mont(); + for i in 0..16 { + table.push(acc.clone()); + if i < 15 { + acc = self.mul_raw(&acc, &base_m); + } + } + let mut result = self.one_mont(); + let nibbles = exp.bits().div_ceil(4); + for idx in (0..nibbles).rev() { + // 4 次平方 + for _ in 0..4 { + result = self.mul_raw(&result, &result); + } + // 取 exp 的第 idx 个 nibble + let bit0 = idx * 4; + let mut n = 0usize; + for b in 0..4 { + if exp.bit(bit0 + b) { + n |= 1 << b; + } + } + if n != 0 { + result = self.mul_raw(&result, &table[n]); + } + } + self.from_mont_as_big(&result) + } + + /// Montgomery 形式的 1。 + fn one_mont(&self) -> Vec { + let one = BigUint::one(); + self.to_mont(&one.limbs) + } + + /// Montgomery 形态 → 普通 BigUint。 + fn from_mont_as_big(&self, a: &[u64]) -> BigUint { + BigUint { limbs: self.from_mont(a) }.normalized() + } +} + +#[cfg(test)] +mod tests { + use super::*; + + fn s(seed: u8) -> Stream { + Stream::new(&[seed; 32]) + } + + #[test] + fn add_sub_mul_basic() { + let a = BigUint::from_u64(u64::MAX); + let b = BigUint::from_u64(3); + assert_eq!(a.add(&b), BigUint::from_u128(1u128 << 64).add(&BigUint::from_u64(2))); + assert_eq!(a.add(&b).sub(&b), a); + assert_eq!(a.mul(&b), BigUint::from_u128(u64::MAX as u128 * 3)); + } + + #[test] + fn cmp_and_bits() { + let a = BigUint::from_u64(1).shl(100); + assert_eq!(a.bits(), 101); + assert!(a.bit(100) && !a.bit(99)); + assert_eq!(a.cmp(&a.sub(&BigUint::one())), core::cmp::Ordering::Greater); + } + + #[test] + fn divmod_single_and_multi() { + let a = BigUint::from_u128(u128::MAX); + let d = BigUint::from_u64(7); + let (q, r) = a.divmod(&d).unwrap(); + assert_eq!(q.mul(&d).add(&r), a); + assert!(r.cmp(&d) == core::cmp::Ordering::Less); + + let a = BigUint::from_u64(1).shl(200).add(&BigUint::from_u64(12345)); + let d = BigUint::from_u64(1).shl(97).add(&BigUint::from_u64(77)); + let (q, r) = a.divmod(&d).unwrap(); + assert_eq!(q.mul(&d).add(&r), a); + assert!(r.cmp(&d) == core::cmp::Ordering::Less); + } + + #[test] + fn modpow_matches_repeated_mul() { + let m = BigUint::from_u64(1_000_003); // 素数 + let base = BigUint::from_u64(123456); + let exp = BigUint::from_u64(1000); + let mut acc = BigUint::one(); + for _ in 0..1000 { + acc = acc.mul(&base).rem(&m); + } + assert_eq!(base.modpow(&exp, &m).unwrap(), acc); + } + + #[test] + fn modpow_large_random() { + let mut st = s(11); + let mut m = BigUint::random_bits(256, &mut st); + m.set_bit(0); // 奇数模数 + let a = BigUint::random_bits(300, &mut st); + let e = BigUint::random_bits(129, &mut st); + let got = a.modpow(&e, &m).unwrap(); + // 用朴素平方乘再验一遍 + let mut acc = BigUint::one(); + let base = a.rem(&m); + for i in (0..e.bits()).rev() { + acc = acc.mul(&acc).rem(&m); + if e.bit(i) { + acc = acc.mul(&base).rem(&m); + } + } + assert_eq!(got, acc); + } + + #[test] + fn mod_inverse_roundtrip() { + let m = BigUint::from_u64(1_000_003); + for a in [3u64, 77, 123456, 999999] { + let av = BigUint::from_u64(a); + let inv = av.mod_inverse(&m).unwrap(); + assert_eq!(av.mul(&inv).rem(&m), BigUint::one(), "a={a}"); + } + } + + #[test] + fn py_mod_signed() { + let n = BigUint::from_u64(10); + assert_eq!(Signed::from_i64(-7).py_mod(&n), BigUint::from_u64(3)); + assert_eq!(Signed::from_i64(7).py_mod(&n), BigUint::from_u64(7)); + assert_eq!(Signed::from_i64(-10).py_mod(&n), BigUint::from_u64(0)); + assert_eq!(Signed::from_i64(-1).py_mod_u64(8), 7); + assert_eq!(Signed::from_i64(9).py_mod_u64(8), 1); + } + + #[test] + fn hex_roundtrip() { + let v = BigUint::from_u64(0xdeadbeef).shl(100).add(&BigUint::from_u64(42)); + assert_eq!(BigUint::from_hex(&v.to_hex()).unwrap(), v); + } + + #[test] + fn probable_prime_sanity() { + let mut st = s(5); + assert!(BigUint::from_u64(1_000_003).is_probable_prime(16, &mut st)); + assert!(!BigUint::from_u64(1_000_001).is_probable_prime(16, &mut st)); + } +} diff --git a/crates/nax-he/src/lib.rs b/crates/nax-he/src/lib.rs new file mode 100644 index 0000000..310cfc5 --- /dev/null +++ b/crates/nax-he/src/lib.rs @@ -0,0 +1,53 @@ +//! nax-he —— Paillier 加法同态与 HE-OLE 离线物料。 +//! +//! # 这个 crate 解决什么问题 +//! +//! `nax-core::share::Dealer` 是**半诚实可信第三方**:它发 Beaver 三元组, +//! 但只要它记下自己发的 `a`,再看到在线阶段公开的 `d = x - a` 就能还原 +//! 任何输入。信任假设一倒,协议裸奔。 +//! +//! 这里用 Paillier 加法同态跑 **OLE**(Oblivious Linear Evaluation), +//! 让参与方自己"协商"出三元组 —— 没有第三方,也没有任何一方见过 +//! `a` 或 `b` 的真值。对应参考实现的 `Vault(triples="he")` 路径。 +//! +//! # 分层 +//! +//! ```text +//! bigint 大整数(Montgomery 模幂、Knuth 除法、Miller-Rabin) +//! paillier 加法同态:encrypt / decrypt / add / add_plain / mul_plain +//! ole OLE 响应与环元素编解码(对齐 refs/nax/nax/crypto/ole.py) +//! pir 1-out-of-N 隐匿查询(对齐 refs/nax/nax/crypto/pir.py) +//! triple 无可信发牌方的 Beaver 三元组(对齐 refs/nax/nax/device/offline.py) +//! ``` +//! +//! # 与参考实现的对齐边界 +//! +//! * **确定性部分逐位一致**(golden 向量):`encrypt(m, r)` 指定随机因子 +//! 时的密文、`decrypt`、`add` / `add_plain` / `mul_plain`、负明文取模。 +//! * **随机性部分只对齐语义**:`keygen` 与未指定 `r` 的 `encrypt` 每次 +//! 输出不同(这正是 IND-CPA 要求),测试验证可逆性与同态性质。 +//! * 已知差异:无。实现刻意镜像 Python 的 `%` 向下取整语义, +//! 包括 `decrypt_signed` 的 `m > n//2` 判定边界(恰好 `n//2` 保持非负)。 +//! +//! # 性能与安全声明(别误读) +//! +//! * 性能:同机对照 CPython,1024-bit 密钥单次加密 **约 5 倍**(22ms → +//! 4-5ms),不是数量级。要数量级得上 Karatsuba/汇编/GPU。 +//! * 安全:**未做常数时间保护**(与参考实现同级)。模幂的窗口查表与 +//! 分支会泄露指数/底数的缓存时序。生产部署把私钥操作放进 TEE +//! (`nax-tee` 的 TrustPlan L1/L2),别直接裸跑在共享物理机上。 + +#![cfg_attr(not(feature = "std"), no_std)] +#![deny(unsafe_op_in_unsafe_fn)] +#![warn(missing_docs)] + +extern crate alloc; + +pub mod bigint; +pub mod ole; +pub mod paillier; +pub mod pir; +pub mod triple; + +pub use bigint::{BigIntError, BigUint, Signed}; +pub use paillier::{KeyPair, PrivateKey, PublicKey}; diff --git a/crates/nax-he/src/ole.rs b/crates/nax-he/src/ole.rs new file mode 100644 index 0000000..8c12e47 --- /dev/null +++ b/crates/nax-he/src/ole.rs @@ -0,0 +1,135 @@ +//! OLE 响应与环元素编解码。 +//! +//! 对齐 `refs/nax/nax/crypto/ole.py`。OLE(Oblivious Linear Evaluation) +//! 是把 `u·v` 变成加性分享的两方原语: +//! +//! ```text +//! A → B: Enc_A(u) +//! B 本地: Enc_A(u)^v ⊞ Enc_A(−t) # 同态标量乘 + 一次性掩码 + 再随机化 +//! B → A: 密文 +//! A 解密: u·v − t B 持有: t +//! ``` +//! +//! 两人手上的东西相加正好是 `u·v`,且 B 只见密文、A 只见被 `t` 掩盖的值。 +//! +//! # 两个不能省的细节(参考实现注释里也强调了) +//! +//! 1. **响应密文必须再随机化**:`pub.add(prod, pub.encrypt(−t))` 里的 +//! `encrypt` 自带新鲜随机因子。否则 `v = 0` 时 `mul_plain` 退化成常数 +//! 密文,接收方一眼看穿。 +//! 2. **环元素按无符号 u64 送进 Paillier**:加法同态在 `Z_N` 上进行, +//! 最后只关心结果模 `2^64`,无符号与有符号表示同余。掩码 `t` 的 +//! `-t` 按 Python `%` 语义编码成 `n - t`。 + +use alloc::vec::Vec; + +use nax_core::prg::Stream; + +use crate::bigint::{BigUint, Signed}; +use crate::paillier::{HeError, PublicKey, PrivateKey}; + +/// 逐元素加密环元素数组(`u64` → `BigUint`)。 +pub fn encrypt_ring( + pub_key: &PublicKey, + vals: &[u64], + s: &mut Stream, +) -> Result, HeError> { + let mut out = Vec::with_capacity(vals.len()); + for &v in vals { + out.push(pub_key.encrypt(&BigUint::from_u64(v), None, s)?); + } + Ok(out) +} + +/// 逐元素解密回环元素(`decrypt_signed` 后 `% 2^64`)。 +pub fn decrypt_ring(sk: &PrivateKey, ciphers: &[BigUint]) -> Vec { + ciphers.iter().map(|c| sk.decrypt_signed(c).to_ring_u64()).collect() +} + +/// 环上一次性掩码的编码:`-t` 作为 Paillier 明文。 +fn neg_mask(t: u64) -> Signed { + Signed { neg: t != 0, mag: BigUint::from_u64(t) } +} + +/// 逐元素 OLE 响应:`Enc(u₁..u_m) → Enc(uᵢ·vᵢ − tᵢ)`。 +/// +/// * `pub_key` 是**发起方**的公钥(响应方全程只见密文); +/// * `mult` 是响应方的私有乘数 `v`; +/// * `mask` 是响应方现取的一次性掩码 `t`,同时是它自己那份分享。 +pub fn ole_respond( + pub_key: &PublicKey, + ciphers: &[BigUint], + mult: &[u64], + mask: &[u64], + s: &mut Stream, +) -> Result, HeError> { + if !(ciphers.len() == mult.len() && mult.len() == mask.len()) { + return Err(HeError::BadPlaintext); + } + let mut out = Vec::with_capacity(ciphers.len()); + for ((c, &vi), &ti) in ciphers.iter().zip(mult.iter()).zip(mask.iter()) { + let prod = pub_key.mul_plain(c, &BigUint::from_u64(vi))?; + // 减掩码的同时重新随机化(encrypt 引入新鲜 r^N 因子) + out.push(pub_key.add(&prod, &pub_key.encrypt_signed(&neg_mask(ti), None, s)?)); + } + Ok(out) +} + +/// 矩阵版 OLE 响应:`Enc(A) , B ↦ Enc(A@B − T)`(或 `A , Enc(B)`)。 +/// +/// 同态只支持「密文 × 明文标量」,矩阵乘展开成逐元素累乘: +/// `Enc(C[p,q]) = ∏ₗ Enc(A[p,l]) ^ B[l,q]`。 +/// 共 `m·n·k` 次模幂 —— HE 预处理最贵的地方,矩阵越"瘦"越划算。 +pub fn ole_respond_matmul( + pub_key: &PublicKey, + ciphers: &[BigUint], + cipher_shape: (usize, usize), + plain: &[u64], + plain_cols: usize, + mask: &[u64], + cipher_on_left: bool, + s: &mut Stream, +) -> Result, HeError> { + let (m, k, n) = if cipher_on_left { + let (m, k) = cipher_shape; + (m, k, plain_cols) + } else { + let (k, n) = cipher_shape; + (plain_cols, k, n) + }; + if plain.len() != if cipher_on_left { k * n } else { m * k } { + return Err(HeError::BadPlaintext); + } + if mask.len() != m * n { + return Err(HeError::BadPlaintext); + } + let mut out = Vec::with_capacity(m * n); + for p in 0..m { + for q in 0..n { + let mut acc: Option = None; + for l in 0..k { + let term = if cipher_on_left { + // Enc(A[p,l]) ^ B[l,q] + let c = &ciphers[p * k + l]; + pub_key.mul_plain(c, &BigUint::from_u64(plain[l * n + q]))? + } else { + // Enc(B[l,q]) ^ A[p,l] + let c = &ciphers[l * n + q]; + pub_key.mul_plain(c, &BigUint::from_u64(plain[p * k + l]))? + }; + acc = Some(match acc { + None => term, + Some(a) => pub_key.add(&a, &term), + }); + } + // k == 0 时按参考实现补 Enc(0) + let acc = match acc { + Some(a) => a, + None => pub_key.encrypt(&BigUint::zero(), None, s)?, + }; + let t = mask[p * n + q]; + out.push(pub_key.add(&acc, &pub_key.encrypt_signed(&neg_mask(t), None, s)?)); + } + } + Ok(out) +} diff --git a/crates/nax-he/src/paillier.rs b/crates/nax-he/src/paillier.rs new file mode 100644 index 0000000..0f8d736 --- /dev/null +++ b/crates/nax-he/src/paillier.rs @@ -0,0 +1,269 @@ +//! Paillier 加法同态加密。 +//! +//! 语义与 `refs/nax/nax/crypto/paillier.py` **逐位对齐**: +//! +//! * `g = n + 1` 标准优化:加密只需一次 `r^n mod n²`; +//! * 解密走 CRT(`p²`/`q²` 两个小模幂 + 合并),比直接在 `n²` 上快约 4 倍; +//! * 明文空间 `Z_n`,负数按 Python `%` 的**向下取整**语义编码 +//! (`encrypt(-t)` 加密的是 `n - t`,不是补码); +//! * `decrypt_signed` 把 `Z_n` 映射回对称区间,边界是 `m > n//2` —— +//! 恰好等于 `n//2` 时**保持非负**(与 Python 的 `>` 而非 `>=` 一致)。 +//! +//! 同态性质:`D(E(m₁)·E(m₂) mod n²) = m₁ + m₂`, +//! `D(E(m)^k mod n²) = k·m`。 + +use alloc::vec::Vec; + +use nax_core::prg::Stream; + +use crate::bigint::{BigIntError, BigUint, Signed, MontCtx}; + +/// 公钥。 +#[derive(Debug, Clone)] +pub struct PublicKey { + /// 模数 `n = p·q`。 + pub n: BigUint, + nsq: BigUint, + mont: MontCtx, +} + +/// 私钥。解密走 CRT 分解。 +#[derive(Debug, Clone)] +pub struct PrivateKey { + /// 对应公钥。 + pub public: PublicKey, + p: BigUint, + q: BigUint, + hp: BigUint, + hq: BigUint, + q_inv_p: BigUint, + mont_p: MontCtx, + mont_q: MontCtx, +} + +/// 密钥对。 +#[derive(Debug, Clone)] +pub struct KeyPair { + /// 公钥。 + pub public: PublicKey, + /// 私钥。 + pub private: PrivateKey, +} + +/// Paillier 错误。 +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum HeError { + /// 大数算术错误。 + BigInt(BigIntError), + /// 密钥不合法(p、q 不互素或太小)。 + BadKey, + /// 明文超范围且无法按语义映射。 + BadPlaintext, +} + +impl From for HeError { + fn from(e: BigIntError) -> Self { + Self::BigInt(e) + } +} + +impl core::fmt::Display for HeError { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + match self { + Self::BigInt(e) => core::write!(f, "大数错误: {e}"), + Self::BadKey => f.write_str("非法密钥"), + Self::BadPlaintext => f.write_str("非法明文"), + } + } +} + +#[cfg(feature = "std")] +impl std::error::Error for HeError {} + +impl PublicKey { + /// 从 `n` 构造公钥(`n` 必须是两个奇素数之积)。 + pub fn new(n: BigUint) -> Result { + if n.is_even() || n.cmp(&BigUint::from_u64(4)) == core::cmp::Ordering::Less { + return Err(HeError::BadKey); + } + let nsq = n.mul(&n); + let mont = MontCtx::new(&nsq)?; + Ok(Self { n, nsq, mont }) + } + + /// `n²`。 + pub fn nsq(&self) -> &BigUint { + &self.nsq + } + + /// 加密 `m ∈ [0, n)`。`r = None` 时取新鲜随机因子。 + /// + /// 对齐 Python:`((1 + n·m) mod n²) · r^n mod n²`。 + /// 指定 `r` 是确定性的(golden 向量靠它做逐位对照); + /// 未指定 `r` 时随机因子来自 PRG 流。 + pub fn encrypt(&self, m: &BigUint, r: Option<&BigUint>, s: &mut Stream) -> Result { + let m = m.rem(&self.n); + let r = match r { + Some(r) => r.clone(), + None => BigUint::random_unit(&self.n, s), + }; + let g_m = BigUint::one().add(&self.n.mul(&m)).rem(&self.nsq); + let rn = self.mont.modpow(&r, &self.n); + Ok(g_m.mul(&rn).rem(&self.nsq)) + } + + /// 加密有符号明文(Python `m %= n` 的向下取整语义)。 + pub fn encrypt_signed(&self, m: &Signed, r: Option<&BigUint>, s: &mut Stream) -> Result { + self.encrypt(&m.py_mod(&self.n), r, s) + } + + /// 密文相加(同态):`c₁ · c₂ mod n²`。 + pub fn add(&self, c1: &BigUint, c2: &BigUint) -> BigUint { + c1.mul(c2).rem(&self.nsq) + } + + /// 密文加明文:`c · (1 + n·m) mod n²`。 + pub fn add_plain(&self, c: &BigUint, m: &BigUint) -> BigUint { + let gm = BigUint::one().add(&self.n.mul(&m.rem(&self.n))).rem(&self.nsq); + c.mul(&gm).rem(&self.nsq) + } + + /// 同态标量乘:`c^k mod n²`。对齐 Python:指数先 `k % n`。 + pub fn mul_plain(&self, c: &BigUint, k: &BigUint) -> Result { + let e = k.rem(&self.n); + Ok(self.mont.modpow(c, &e)) + } + + /// 同态标量乘(有符号指数):Python 的 `k % n` 是向下取整语义, + /// 负指数等价于 `n - (|k| % n)`。PIR 的负权值走这条路。 + pub fn mul_plain_signed(&self, c: &BigUint, k: &Signed) -> Result { + let e = k.py_mod(&self.n); + Ok(self.mont.modpow(c, &e)) + } + + /// 逐元素加密。 + pub fn encrypt_vec(&self, ms: &[BigUint], s: &mut Stream) -> Result, HeError> { + let mut out = Vec::with_capacity(ms.len()); + for m in ms { + out.push(self.encrypt(m, None, s)?); + } + Ok(out) + } + + /// 逐元素同态求和(多组向量按列相加)。 + pub fn sum_vec(&self, vecs: &[Vec]) -> Vec { + assert!(!vecs.is_empty()); + let mut acc = vecs[0].clone(); + for v in &vecs[1..] { + for (a, b) in acc.iter_mut().zip(v.iter()) { + *a = self.add(a, b); + } + } + acc + } +} + +/// `L(x) = (x - 1) / m`(Paillier 的 L 函数)。 +fn l_func(x: &BigUint, m: &BigUint) -> BigUint { + x.sub(&BigUint::one()).divmod(m).expect("L 函数除法").0 +} + +impl PrivateKey { + /// 从公钥与素因子构造。`p`、`q` 必须是不同奇素数。 + pub fn new(public: PublicKey, p: BigUint, q: BigUint) -> Result { + if p == q || p.is_even() || q.is_even() { + return Err(HeError::BadKey); + } + let n = p.mul(&q); + if n != public.n { + return Err(HeError::BadKey); + } + let psq = p.mul(&p); + let qsq = q.mul(&q); + let mont_p = MontCtx::new(&psq)?; + let mont_q = MontCtx::new(&qsq)?; + // hp = L(g^{p-1} mod p²)^{-1} mod p,g = n + 1 + let g = public.n.add(&BigUint::one()); + let gp = mont_p.modpow(&g, &p.sub(&BigUint::one())); + let hp = l_func(&gp, &p).mod_inverse(&p)?; + let gq = mont_q.modpow(&g, &q.sub(&BigUint::one())); + let hq = l_func(&gq, &q).mod_inverse(&q)?; + let q_inv_p = q.mod_inverse(&p)?; + Ok(Self { public, p, q, hp, hq, q_inv_p, mont_p, mont_q }) + } + + /// 解密,结果落在 `[0, n)`。 + /// + /// CRT 版:`m = CRT(L(c^{p-1} mod p²)·hp mod p, L(c^{q-1} mod q²)·hq mod q)`。 + pub fn decrypt(&self, c: &BigUint) -> BigUint { + let cp = self.mont_p.modpow(c, &self.p.sub(&BigUint::one())); + let mp = l_func(&cp, &self.p).mul(&self.hp).rem(&self.p); + let cq = self.mont_q.modpow(c, &self.q.sub(&BigUint::one())); + let mq = l_func(&cq, &self.q).mul(&self.hq).rem(&self.q); + // CRT 合并:t = (mp - mq) · q_inv_p mod p;m = mq + t·q + // mp、mq 都已在 [0, p),差落在 (-p, p),负差 +p 即得 Python 的 + // 向下取整语义(恰好 0 时结果就是 0,不能错成 p) + let diff_mod = if mp.cmp(&mq) == core::cmp::Ordering::Less { + self.p.sub(&mq.sub(&mp)) + } else { + mp.sub(&mq) + }; + let t = diff_mod.mul(&self.q_inv_p).rem(&self.p); + mq.add(&t.mul(&self.q)).rem(&self.public.n) + } + + /// 解密并映射到对称区间:`m > n//2` 时减 `n`。 + /// + /// 边界与 Python 一致:恰好 `n//2` 保持非负。 + pub fn decrypt_signed(&self, c: &BigUint) -> Signed { + let m = self.decrypt(c); + let half = self.public.n.shr(1); // n//2(Python 整除) + if m.cmp(&half) == core::cmp::Ordering::Greater { + Signed { neg: true, mag: self.public.n.sub(&m) } + } else { + Signed { neg: false, mag: m } + } + } + + /// 逐元素解密(带符号)。 + pub fn decrypt_vec(&self, cs: &[BigUint]) -> Vec { + cs.iter().map(|c| self.decrypt_signed(c)).collect() + } + + /// 公开的素因子(仅测试用;生产绝不外传)。 + pub fn factors(&self) -> (&BigUint, &BigUint) { + (&self.p, &self.q) + } +} + +/// 生成 Paillier 密钥对(`bits` 是模数 `n` 的位数)。 +/// +/// 随机性来自 `Stream` —— **生产环境必须用 OS 熵源播种** +/// (参考实现用 `secrets`;这里保持项目"可复现 PRG"的统一约定, +/// 调用方在部署时读 `/dev/urandom` 播种)。 +pub fn keygen(bits: usize, s: &mut Stream) -> Result { + assert!(bits >= 16, "keygen 位数太小"); + let half = bits / 2; + let p = gen_prime(half, s); + let mut q = gen_prime(half, s); + while q == p { + q = gen_prime(half, s); + } + let n = p.mul(&q); + let public = PublicKey::new(n)?; + let private = PrivateKey::new(public.clone(), p, q)?; + Ok(KeyPair { public, private }) +} + +/// 生成一个 `bits` 位的随机素数(与 Python `_gen_prime` 同构)。 +fn gen_prime(bits: usize, s: &mut Stream) -> BigUint { + loop { + let mut p = BigUint::random_bits(bits, s); + // p |= (1 << (bits-1)) | 1 —— 置顶位与最低位 + p.set_bit(bits - 1); + p.set_bit(0); + if p.is_probable_prime(24, s) { + return p; + } + } +} diff --git a/crates/nax-he/src/pir.rs b/crates/nax-he/src/pir.rs new file mode 100644 index 0000000..ee0eeaf --- /dev/null +++ b/crates/nax-he/src/pir.rs @@ -0,0 +1,72 @@ +//! 1-out-of-N 隐匿查询(PIR),基于 Paillier 加法同态。 +//! +//! 对齐 `refs/nax/nax/crypto/pir.py`: +//! +//! 1. 客户端把查询下标 `i` 编码成单位向量,逐元素加密发给服务端; +//! 2. 服务端在密文上做加权求和 `Enc(Σⱼ eⱼ·aⱼ) = ∏ⱼ Enc(eⱼ)^{aⱼ}`; +//! 3. 客户端解密得到 `aᵢ`。 +//! +//! 服务端只看到一串密文的单位向量,无法区分是哪一个 +//! (Paillier 语义安全)。代价是通信量与 N 成比 —— 教学版 PIR 的 +//! 典型取舍,生产要上 SealPIR 之类子线性方案。 +//! +//! # 定点约定 +//! +//! 服务端把 `f64` 记录定点化成 `round(x · 2^18)` 后做整数指数 —— +//! 与参考实现一致(Python `round()` 与 `np.rint` 同为银行家舍入, +//! 这里复用 `nax_core::ring::encode`)。表示范围 `|x| < 2^62 / 2^18`。 + +use alloc::vec::Vec; + +use nax_core::prg::Stream; +use nax_core::ring; + +use crate::bigint::{BigUint, Signed}; +use crate::paillier::{HeError, PrivateKey, PublicKey}; + +/// 默认定点小数位,与参考实现一致。 +pub const PIR_FXP: u32 = 18; + +/// 生成加密的单位查询向量(`e[index] = 1`,其余 0)。 +pub fn client_query( + pub_key: &PublicKey, + index: usize, + n: usize, + s: &mut Stream, +) -> Result, HeError> { + if index >= n { + return Err(HeError::BadPlaintext); + } + let mut out = Vec::with_capacity(n); + for j in 0..n { + let v = BigUint::from_u64(if j == index { 1 } else { 0 }); + out.push(pub_key.encrypt(&v, None, s)?); + } + Ok(out) +} + +/// 服务端在密文上加权求和:`∏ⱼ Enc(eⱼ)^{aⱼ}`。 +/// +/// 权值先定点化(可为负,走 Python 的 `k % n` 向下取整语义)。 +pub fn server_answer( + pub_key: &PublicKey, + items: &[f64], + query: &[BigUint], + s: &mut Stream, +) -> Result { + if items.len() != query.len() { + return Err(HeError::BadPlaintext); + } + let mut acc = pub_key.encrypt(&BigUint::zero(), None, s)?; + for (a_j, c_j) in items.iter().zip(query.iter()) { + let scaled = ring::encode(*a_j, PIR_FXP).map_err(|_| HeError::BadPlaintext)? as i64; + let term = pub_key.mul_plain_signed(c_j, &Signed::from_i64(scaled))?; + acc = pub_key.add(&acc, &term); + } + Ok(acc) +} + +/// 客户端解密并还原成 `f64`。 +pub fn client_recover(sk: &PrivateKey, cipher: &BigUint) -> f64 { + sk.decrypt_signed(cipher).to_f64() / ((1u64 << PIR_FXP) as f64) +} diff --git a/crates/nax-he/src/triple.rs b/crates/nax-he/src/triple.rs new file mode 100644 index 0000000..f56df0f --- /dev/null +++ b/crates/nax-he/src/triple.rs @@ -0,0 +1,266 @@ +//! 无可信发牌方的 Beaver 三元组(HE-OLE 协商)。 +//! +//! 对齐 `refs/nax/nax/device/offline.py` 的 `HESource._negotiate`: +//! +//! ```text +//! (Σaᵢ)(Σbᵢ) = Σᵢ aᵢbᵢ + Σ_{i Stream { + Stream::derive(master, label) +} + +/// 环上逐元素乘。 +fn ring_mul(a: &[u64], b: &[u64], out: &mut [u64]) { + ring::mul_into(a, b, out).expect("ring mul 长度一致"); +} + +/// 环上加法。 +fn ring_add(a: &[u64], b: &[u64], out: &mut [u64]) { + ring::add_into(a, b, out).expect("ring add 长度一致"); +} + +/// 环上原地加:`acc += b`。 +fn ring_add_assign(acc: &mut [u64], b: &[u64]) { + for (x, y) in acc.iter_mut().zip(b.iter()) { + *x = x.wrapping_add(*y); + } +} + +/// 逐元素 Beaver 三元组(无可信发牌方)。 +/// +/// 输出布局与 `nax_core::share::mul_triple_into` 一致: +/// `a_sh[p * len + i]` 是第 `p` 方持有的 `a` 分片。 +pub fn mul_triple_into( + n: usize, + len: usize, + master: &[u8; 32], + he_bits: usize, + a_sh: &mut [u64], + b_sh: &mut [u64], + c_sh: &mut [u64], +) -> Result<(), HeError> { + assert!(n >= 2, "HE 物料至少两方"); + assert!(a_sh.len() >= n * len && b_sh.len() >= n * len && c_sh.len() >= n * len); + + // 1) 各方本地取随机 aᵢ / bᵢ(全环宽,与参考实现 random_ring 一致) + let mut a: Vec> = Vec::with_capacity(n); + let mut b: Vec> = Vec::with_capacity(n); + for i in 0..n { + let mut ai = vec![0u64; len]; + let mut bi = vec![0u64; len]; + derive(master, &party_label(b"he/rand/a", i)).fill_u64(&mut ai); + derive(master, &party_label(b"he/rand/b", i)).fill_u64(&mut bi); + a.push(ai); + b.push(bi); + } + + // 2) 本地项 accᵢ = aᵢ · bᵢ + let mut acc: Vec> = Vec::with_capacity(n); + for i in 0..n { + let mut c = vec![0u64; len]; + ring_mul(&a[i], &b[i], &mut c); + acc.push(c); + } + + // 3) 逐对双向 OLE + let mut keys = Vec::with_capacity(n); + for i in 0..n { + let mut ks = derive(master, &party_label(b"he/key", i)); + keys.push(paillier::keygen(he_bits, &mut ks)?); + } + for i in 0..n { + // 发起方把 aᵢ、bᵢ 加密一次,供所有对端复用(与参考实现一致) + let mut es = derive(master, &party_label(b"he/enc", i)); + let ca = ole::encrypt_ring(&keys[i].public, &a[i], &mut es)?; + let cb = ole::encrypt_ring(&keys[i].public, &b[i], &mut es)?; + for j in (i + 1)..n { + let mut rs = derive(master, &pair_label(b"he/mask", i, j)); + let t1 = { + let mut v = vec![0u64; len]; + rs.fill_u64(&mut v); + v + }; + let t2 = { + let mut v = vec![0u64; len]; + rs.fill_u64(&mut v); + v + }; + // 响应方 j:Enc(aᵢ·bⱼ − t1)、Enc(bᵢ·aⱼ − t2),自留 t1 + t2 + let mut rs2 = derive(master, &pair_label(b"he/ole", i, j)); + let resp_a = ole::ole_respond(&keys[i].public, &ca, &b[j], &t1, &mut rs2)?; + let resp_b = ole::ole_respond(&keys[i].public, &cb, &a[j], &t2, &mut rs2)?; + // 发起方 i 解密,拿到自己那半边交叉项 + let u = ole::decrypt_ring(&keys[i].private, &resp_a); + let v = ole::decrypt_ring(&keys[i].private, &resp_b); + let mut cross = vec![0u64; len]; + ring_add(&u, &v, &mut cross); + ring_add_assign(&mut acc[i], &cross); + // 响应方 j 加上掩码 + let mut mask = vec![0u64; len]; + ring_add(&t1, &t2, &mut mask); + ring_add_assign(&mut acc[j], &mask); + } + } + + // 4) 写平铺输出 + for p in 0..n { + let base = p * len; + a_sh[base..base + len].copy_from_slice(&a[p]); + b_sh[base..base + len].copy_from_slice(&b[p]); + c_sh[base..base + len].copy_from_slice(&acc[p]); + } + Ok(()) +} + +/// 矩阵 Beaver 三元组(无可信发牌方):`A (rows×k) · B (k×cols) = C`。 +/// +/// 输出布局与 `nax_core::share::matmul_triple_into` 一致。 +pub fn matmul_triple_into( + n: usize, + rows: usize, + k: usize, + cols: usize, + master: &[u8; 32], + he_bits: usize, + a_sh: &mut [u64], + b_sh: &mut [u64], + c_sh: &mut [u64], +) -> Result<(), HeError> { + assert!(n >= 2, "HE 物料至少两方"); + let (a_len, b_len, c_len) = (rows * k, k * cols, rows * cols); + assert!(a_sh.len() >= n * a_len && b_sh.len() >= n * b_len && c_sh.len() >= n * c_len); + + let mut a: Vec> = Vec::with_capacity(n); + let mut b: Vec> = Vec::with_capacity(n); + for i in 0..n { + let mut ai = vec![0u64; a_len]; + let mut bi = vec![0u64; b_len]; + derive(master, &party_label(b"he/mrand/a", i)).fill_u64(&mut ai); + derive(master, &party_label(b"he/mrand/b", i)).fill_u64(&mut bi); + a.push(ai); + b.push(bi); + } + + let mut acc: Vec> = Vec::with_capacity(n); + for i in 0..n { + let mut c = vec![0u64; c_len]; + ring::matmul_into(rows, k, cols, &a[i], &b[i], &mut c).expect("形状一致"); + acc.push(c); + } + + let mut keys = Vec::with_capacity(n); + for i in 0..n { + let mut ks = derive(master, &party_label(b"he/key", i)); + keys.push(paillier::keygen(he_bits, &mut ks)?); + } + for i in 0..n { + let mut es = derive(master, &party_label(b"he/menc", i)); + let ca = ole::encrypt_ring(&keys[i].public, &a[i], &mut es)?; + let cb = ole::encrypt_ring(&keys[i].public, &b[i], &mut es)?; + for j in (i + 1)..n { + let mut rs = derive(master, &pair_label(b"he/mmask", i, j)); + let mut t1 = vec![0u64; c_len]; + let mut t2 = vec![0u64; c_len]; + rs.fill_u64(&mut t1); + rs.fill_u64(&mut t2); + let mut rs2 = derive(master, &pair_label(b"he/mole", i, j)); + // Enc(Aᵢ) @ Bⱼ − T1 + let resp_a = ole::ole_respond_matmul( + &keys[i].public, + &ca, + (rows, k), + &b[j], + cols, + &t1, + true, + &mut rs2, + )?; + // Aⱼ @ Enc(Bᵢ) − T2 + let resp_b = ole::ole_respond_matmul( + &keys[i].public, + &cb, + (k, cols), + &a[j], + rows, + &t2, + false, + &mut rs2, + )?; + let u = ole::decrypt_ring(&keys[i].private, &resp_a); + let v = ole::decrypt_ring(&keys[i].private, &resp_b); + let mut cross = vec![0u64; c_len]; + ring_add(&u, &v, &mut cross); + ring_add_assign(&mut acc[i], &cross); + let mut mask = vec![0u64; c_len]; + ring_add(&t1, &t2, &mut mask); + ring_add_assign(&mut acc[j], &mask); + } + } + + for p in 0..n { + let base = p * a_len; + a_sh[base..base + a_len].copy_from_slice(&a[p]); + let base = p * b_len; + b_sh[base..base + b_len].copy_from_slice(&b[p]); + let base = p * c_len; + c_sh[base..base + c_len].copy_from_slice(&acc[p]); + } + Ok(()) +} + +/// 单方标签:`tag|idx`。 +fn party_label(tag: &[u8], idx: usize) -> Vec { + let mut l = Vec::with_capacity(tag.len() + 4); + l.extend_from_slice(tag); + l.push(b'/'); + l.extend_from_slice(&(idx as u32).to_le_bytes()); + l +} + +/// 成对标签:`tag|i|j`(有序,(i,j) 与 (j,i) 不同流 —— 角色不同)。 +fn pair_label(tag: &[u8], i: usize, j: usize) -> Vec { + let mut l = party_label(tag, i); + l.extend_from_slice(&(j as u32).to_le_bytes()); + l +} diff --git a/crates/nax-he/tests/bench_he.rs b/crates/nax-he/tests/bench_he.rs new file mode 100644 index 0000000..8c53897 --- /dev/null +++ b/crates/nax-he/tests/bench_he.rs @@ -0,0 +1,87 @@ +//! HE 性能基准(手动跑,不进 CI)。 +//! +//! ```bash +//! cargo test --release -p nax-he --test bench_he -- --ignored --nocapture +//! ``` +//! +//! 数字要与 Python 参考实现**同机同密钥长度**对照,别拿不同机器的数字比。 + +use std::time::Instant; + +use nax_core::prg::Stream; +use nax_he::bigint::BigUint; +use nax_he::ole; +use nax_he::paillier::{self, PublicKey}; + +fn stream(seed: u8) -> Stream { + Stream::new(&[seed; 32]) +} + +fn bench_key(bits: usize, tag: &str) { + let mut s = stream(1); + let t0 = Instant::now(); + let kp = paillier::keygen(bits, &mut s).unwrap(); + let dt = t0.elapsed(); + println!("keygen({bits:>4}) {dt:>10.1?}"); + + // 加密(10 个元素取平均) + let mut s = stream(2); + let ms: Vec = (0..10u64).map(BigUint::from_u64).collect(); + let t0 = Instant::now(); + let mut cs = Vec::new(); + for m in &ms { + cs.push(kp.public.encrypt(m, None, &mut s).unwrap()); + } + let enc = t0.elapsed() / ms.len() as u32; + + // 解密 + let t0 = Instant::now(); + for c in &cs { + std::hint::black_box(kp.private.decrypt_signed(c)); + } + let dec = t0.elapsed() / cs.len() as u32; + + // 同态标量乘 + let t0 = Instant::now(); + for c in &cs { + std::hint::black_box(kp.public.mul_plain(c, &BigUint::from_u64(12345)).unwrap()); + } + let mp = t0.elapsed() / cs.len() as u32; + + // 密文加 + let t0 = Instant::now(); + for i in 0..cs.len() - 1 { + std::hint::black_box(kp.public.add(&cs[i], &cs[i + 1])); + } + let add = t0.elapsed() / (cs.len() - 1) as u32; + + println!( + "{tag} n={bits} bit: encrypt {enc:>10.1?}/elem decrypt {dec:>10.1?}/elem mul_plain {mp:>10.1?}/elem add {add:>10.1?}/elem" + ); +} + +#[test] +#[ignore] +fn bench_he() { + bench_key(512, "small"); + bench_key(1024, "large"); + + // OLE 一条(encrypt + mul_plain + encrypt(-t) + add + decrypt) + let kp = paillier::keygen(1024, &mut stream(3)).unwrap(); + let mut sa = stream(4); + let mut sb = stream(5); + let u: Vec = (0..64).map(|i| i * 7919).collect(); + let v: Vec = (0..64).map(|i| i * 104729).collect(); + let mut t = vec![0u64; 64]; + sb.fill_u64(&mut t); + let t0 = Instant::now(); + 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 _ = ole::decrypt_ring(&kp.private, &resp); + let per = t0.elapsed() / 64; + println!("OLE 完整一轮(1024-bit) {per:>10.1?}/elem (encrypt+mul_plain+re-randomize+decrypt)"); + + //2048-bit(生产建议位数) + bench_key(2048, "prod"); + let _ = PublicKey::new(BigUint::one()); +} diff --git a/crates/nax-he/tests/golden_paillier.rs b/crates/nax-he/tests/golden_paillier.rs new file mode 100644 index 0000000..f85508e --- /dev/null +++ b/crates/nax-he/tests/golden_paillier.rs @@ -0,0 +1,135 @@ +//! **自动生成,请勿手改。** +//! +//! 由 `tools/gen_golden.py` 从参考实现 `refs/nax/nax/crypto/paillier.py` 导出。 +//! 用例数:50 +//! +//! 重新生成: +//! ```bash +//! .venv/bin/python tools/gen_golden.py +//! ``` +//! +//! 这个文件的意义:Rust 的 Paillier 与 Python 参考实现必须给出**逐位相同** +//! 的密文与解密结果(给定相同明文与随机因子 r)。一旦某次改动让这里变红, +//! 说明语义漂移了 —— 不要去"放宽断言",先确认哪一边才是对的。 + +#![allow(clippy::unreadable_literal)] + +use nax_core::prg::Stream; +use nax_he::bigint::{BigUint, Signed}; +use nax_he::paillier::{KeyPair, PrivateKey, PublicKey}; + +fn h(s: &str) -> BigUint { + BigUint::from_hex(s).unwrap() +} + +fn dead_stream() -> Stream { + Stream::new(&[0u8; 32]) +} + +fn build_kp(p: &str, q: &str) -> KeyPair { + let (p, q) = (h(p), h(q)); + let pubk = PublicKey::new(p.mul(&q)).unwrap(); + let privk = PrivateKey::new(pubk.clone(), p, q).unwrap(); + KeyPair { public: pubk, private: privk } +} + +fn small() -> KeyPair { + build_kp("fe90d12c57de865ae8377de5d2d35215d9ed1ccf0abc3d1d4eb8c8003e33cea9", "ea2a28a8f18c79639c8b371706cb3f5c887346090034396930233b9ca2bf0cef") +} + +fn big() -> KeyPair { + build_kp("fbbf51875fc74ceda86f0806a7a7785f32b6a08d1f107b5e58c4cad65e273c12cc33d2ece61952a2ecaedf34ecbc031a478c4724f1f64a71f95f77b9e3921e07", "c0be0194b334880dbb8afcc514dc8825c9b655e7a43b1000970ec134901859c4d57df87bca790891703058cd35def9f968f26d5190ff72c41bf15635bc6adfb7") +} + +/// encrypt(m, r) 逐位对照(r 显式给定 → 密文确定性)。 +fn check_encrypt(kp: &KeyPair, m: &BigUint, r: &BigUint, want: &BigUint) { + let c = kp.public.encrypt(m, Some(r), &mut dead_stream()).unwrap(); + assert_eq!(c.to_hex(), want.to_hex(), "encrypt(m={}, r={})", m.to_hex(), r.to_hex()); +} + +/// decrypt_signed 逐位对照。 +fn check_decrypt(kp: &KeyPair, c: &BigUint, want_neg: bool, want_mag: &BigUint, label: &str) { + let s = kp.private.decrypt_signed(c); + assert_eq!(s.neg, want_neg, "decrypt_signed({}).neg", label); + assert_eq!(s.mag.to_hex(), want_mag.to_hex(), "decrypt_signed({}).mag", label); +} + +/// 同态算子逐位对照:add(c1,c2) / add_plain(c1,17) / mul_plain(c2,2)。 +fn check_hom( + kp: &KeyPair, + c1: &BigUint, + c2: &BigUint, + want_add: &BigUint, + want_add_plain: &BigUint, + want_mul_plain: &BigUint, +) { + assert_eq!(kp.public.add(c1, c2).to_hex(), want_add.to_hex(), "add"); + assert_eq!(kp.public.add_plain(c1, &BigUint::from_u64(17)).to_hex(), want_add_plain.to_hex(), "add_plain"); + assert_eq!( + kp.public.mul_plain(c2, &BigUint::from_u64(2)).unwrap().to_hex(), + want_mul_plain.to_hex(), + "mul_plain" + ); + let _ = Signed::from_i64(0); // 保持 use 引用 +} + +#[test] +fn conformance_with_python_reference() { + // ---- bigint: modpow / divmod / mod_inverse ---- + assert_eq!(h("2").modpow(&h("a"), &h("f4243")).unwrap().to_hex(), "400".to_string(), "modpow"); + assert_eq!(h("1e240").modpow(&h("3e8"), &h("f4243")).unwrap().to_hex(), "c06fd".to_string(), "modpow"); + assert_eq!(h("100000000000000000000000000000000000000000000000005").modpow(&h("2000000000000000000000003"), &h("40000000000000000000000000000004d")).unwrap().to_hex(), "35ad618a333ee3dfb20696256567f26af".to_string(), "modpow"); + assert_eq!(h("deadbeefcafebabe").modpow(&h("400000000000000001"), &h("10000000000000000000000000000000000000015")).unwrap().to_hex(), "40e3e7e1f6ff82f822b14a0efe87084514e2419c".to_string(), "modpow"); + { let (q, r) = h("100000000000000000000000000000000000000000000003039").divmod(&h("200000000000000000000004d")).unwrap(); assert_eq!(q.to_hex(), "7fffffffffffffffffffffecc0".to_string(), "divmod q"); assert_eq!(r.to_hex(), "5fa79".to_string(), "divmod r"); } + { let (q, r) = h("ffffffffffffffffffff").divmod(&h("7")).unwrap(); assert_eq!(q.to_hex(), "24924924924924924924".to_string(), "divmod q"); assert_eq!(r.to_hex(), "3".to_string(), "divmod r"); } + { let (q, r) = h("ffffffffffffffffffffffffffffffff").divmod(&h("fffffffffffffffd")).unwrap(); assert_eq!(q.to_hex(), "10000000000000003".to_string(), "divmod q"); assert_eq!(r.to_hex(), "8".to_string(), "divmod r"); } + assert_eq!(h("3").mod_inverse(&h("f4243")).unwrap().to_hex(), "a2c2d".to_string(), "mod_inverse"); + assert_eq!(h("4d").mod_inverse(&h("f4243")).unwrap().to_hex(), "3c3e2".to_string(), "mod_inverse"); + assert_eq!(h("100000000000000000005").mod_inverse(&h("1ffffffffffffffffffffff")).unwrap().to_hex(), "ab554445f900b3214978a7".to_string(), "mod_inverse"); + + // ---- Paillier 512-bit n ---- + // ---- small: n = 256 bit ---- + check_encrypt(&small(), &h("0"), &h("2"), &h("6dd79736d47dde0f64ff87e64fe11f12411cd3303c0769fa24e1f79ba11f586922072127430b72a3b0835befbdddfc02ca5de7243cb0baefe92ffcd904e787e907ba920529463d559b7d9b6f00955878ab3d51da421e81688274122d58755f362272b59ec713dd482eeb30f6a9e3e3c2605b5e8c388507bd4ac71c0d5b903ca7")); + check_decrypt(&small(), &h("6dd79736d47dde0f64ff87e64fe11f12411cd3303c0769fa24e1f79ba11f586922072127430b72a3b0835befbdddfc02ca5de7243cb0baefe92ffcd904e787e907ba920529463d559b7d9b6f00955878ab3d51da421e81688274122d58755f362272b59ec713dd482eeb30f6a9e3e3c2605b5e8c388507bd4ac71c0d5b903ca7"), false, &h("0"), "0"); + check_encrypt(&small(), &h("1"), &h("3"), &h("4c5bdb1c3419d1bc3cf16649901cbde841148115eb304ae99441c53478de1871ee2b3f3be5375898610e0843d80ea423d7e49275f4ec1d44deecf5661cdddb4660bdf5a7f278a88975db1dad3c57d37e0d4c73b78eb3afafa9bcb98586db77c46b420e223c42242e295a1bda2ebb223a9e58113da7b4f0b3904d5b6f437e79ba")); + check_decrypt(&small(), &h("4c5bdb1c3419d1bc3cf16649901cbde841148115eb304ae99441c53478de1871ee2b3f3be5375898610e0843d80ea423d7e49275f4ec1d44deecf5661cdddb4660bdf5a7f278a88975db1dad3c57d37e0d4c73b78eb3afafa9bcb98586db77c46b420e223c42242e295a1bda2ebb223a9e58113da7b4f0b3904d5b6f437e79ba"), false, &h("1"), "1"); + check_encrypt(&small(), &h("1e240"), &h("3039"), &h("112f3221c70c7547292489f5edfcea7e391a9ed1025ca3380d709a7da8579555564129e3ee0694ba598c3b0cba1284ad5c9e5832ba4ce6b268dd2b1fce762dd4889e04009c7ea62610d3b6c6fe4f0b9e84a831e9fd6c651ce4b0e6dee6d33b13649785dedac05089fcc80f5c7dc0bad825b74f774ea10ae589da3d61b14a39f6")); + check_decrypt(&small(), &h("112f3221c70c7547292489f5edfcea7e391a9ed1025ca3380d709a7da8579555564129e3ee0694ba598c3b0cba1284ad5c9e5832ba4ce6b268dd2b1fce762dd4889e04009c7ea62610d3b6c6fe4f0b9e84a831e9fd6c651ce4b0e6dee6d33b13649785dedac05089fcc80f5c7dc0bad825b74f774ea10ae589da3d61b14a39f6"), false, &h("1e240"), "123456"); + check_encrypt(&small(), &h("e8da4b63798208f835b544db9cb6928ca9905ce22f75ad71c27e7c16515afd622a85b4c2f66e8a8f7042c746f163567be2295517f644a31c50bbce8ea224dbc6"), &h("e8da4b63798208f835b544db9cb6928ca9905ce22f75ad71c27e7c16515afd622a85b4c2f66e8a8f7042c746f163567be2295517f644a31c50bbce8ea224dbc5"), &h("a1528d27faee7de8271a8065e03dadaa11d032867d39872dfd323d7e5adf2f7375c25a0506845a6c97538387c00929132d4e93c8de99dbdbe82105091fea494bfa451bf014bc2369eb149c2f689ce8bee1fbe33ba1331a420cb083ddbd97a6209afbece2f3aeb77ab14bc3eb0589507e13178db6e66bbd625ae076556c7e42cf")); + check_decrypt(&small(), &h("a1528d27faee7de8271a8065e03dadaa11d032867d39872dfd323d7e5adf2f7375c25a0506845a6c97538387c00929132d4e93c8de99dbdbe82105091fea494bfa451bf014bc2369eb149c2f689ce8bee1fbe33ba1331a420cb083ddbd97a6209afbece2f3aeb77ab14bc3eb0589507e13178db6e66bbd625ae076556c7e42cf"), true, &h("1"), "12195486131650044168354063005253372250225651670395170144361492452813796908355947545693884883478244576197260973137312000714301534182408479279674801181219782"); + check_encrypt(&small(), &h("746d25b1bcc1047c1adaa26dce5b494654c82e7117bad6b8e13f3e0b28ad7eb11542da617b374547b82163a378b1ab3df114aa8bfb22518e285de74751126de3"), &h("4d9e19212880ada811e716f3dee7862ee3301ef60fd1e47b40d4d4077073a9cb6381e6eba77a2e2fd016426cfb211cd3f60dc707fcc18bb41ae944da360c4943"), &h("33e45942221e8071b2d84172da7384d2ecb2128448ca868a28928dc6020e24376d314bcd3910093c9cb8151ae35ece381665fc7790014c64d2b8bbb897cbfbca2aeca5f02154af9616eb5bd48dc3459bd650f08f1e1c8cfa74095527ff16889811f903800ae90430d5d671a324106ba426856a8945dbe2f27dc3d50b03d0e5b8")); + check_decrypt(&small(), &h("33e45942221e8071b2d84172da7384d2ecb2128448ca868a28928dc6020e24376d314bcd3910093c9cb8151ae35ece381665fc7790014c64d2b8bbb897cbfbca2aeca5f02154af9616eb5bd48dc3459bd650f08f1e1c8cfa74095527ff16889811f903800ae90430d5d671a324106ba426856a8945dbe2f27dc3d50b03d0e5b8"), false, &h("746d25b1bcc1047c1adaa26dce5b494654c82e7117bad6b8e13f3e0b28ad7eb11542da617b374547b82163a378b1ab3df114aa8bfb22518e285de74751126de3"), "6097743065825022084177031502626686125112825835197585072180746226406898454177973772846942441739122288098630486568656000357150767091204239639837400590609891"); + check_encrypt(&small(), &h("746d25b1bcc1047c1adaa26dce5b494654c82e7117bad6b8e13f3e0b28ad7eb11542da617b374547b82163a378b1ab3df114aa8bfb22518e285de74751126de4"), &h("e8da4b63798208f835b544db9cb6928ca9905ce22f75ad71c27e7c16515afd622a85b4c2f66e8a8f7042c746f163567be2295517f644a31c50bbce8ea224dbc2"), &h("7ae57f4a4b6156e2189d4546f115c4028591d8938c98355409d8b1e9429c7fc2fbfe427c9aa6dca2c629fc142ec250fb46d418cd83e6449ff1abbcdf58c42a8b444befab32fd7c491f30dc92fab673758d38bd18a11b0284c63efd8f163e86406ab60a2052d0ba83df5cda8523508a25dc4cbad3548dc01ba8d78818478fecd9")); + check_decrypt(&small(), &h("7ae57f4a4b6156e2189d4546f115c4028591d8938c98355409d8b1e9429c7fc2fbfe427c9aa6dca2c629fc142ec250fb46d418cd83e6449ff1abbcdf58c42a8b444befab32fd7c491f30dc92fab673758d38bd18a11b0284c63efd8f163e86406ab60a2052d0ba83df5cda8523508a25dc4cbad3548dc01ba8d78818478fecd9"), true, &h("746d25b1bcc1047c1adaa26dce5b494654c82e7117bad6b8e13f3e0b28ad7eb11542da617b374547b82163a378b1ab3df114aa8bfb22518e285de74751126de3"), "6097743065825022084177031502626686125112825835197585072180746226406898454177973772846942441739122288098630486568656000357150767091204239639837400590609892"); + check_encrypt(&small(), &h("e8da4b63798208f835b544db9cb6928ca9905ce22f75ad71c27e7c16515afd622a85b4c2f66e8a8f7042c746f163567be2295517f644a31c50bbce8ea224d8be"), &h("18697"), &h("ccecee1bea04ed4a27a6e20155b3ff6db82285c67904b6cf519b6f33a68a42b97ef992661d5b8917aa3496b61e8cb89f7738d275ae00933cfebf4f106ff58c42ede7dbd9a383e0a6346a0f6f0ff913bbf1f92e891b160723d88d8b97a60d3b6818044ffb09ba705fd05ac04fd95cb5954eb91a3f9ad70823f32923425f59bb73")); + check_decrypt(&small(), &h("ccecee1bea04ed4a27a6e20155b3ff6db82285c67904b6cf519b6f33a68a42b97ef992661d5b8917aa3496b61e8cb89f7738d275ae00933cfebf4f106ff58c42ede7dbd9a383e0a6346a0f6f0ff913bbf1f92e891b160723d88d8b97a60d3b6818044ffb09ba705fd05ac04fd95cb5954eb91a3f9ad70823f32923425f59bb73"), true, &h("309"), "-777"); + check_encrypt(&small(), &h("1"), &h("10001"), &h("95d71f562c9e7f65c8802cbff210f27e38760b60e886505a64338c7479d1737e14d2a137f265f21a16745ffa1b93f096288c76dc6c7a8b7cc2c71cd415c7200263347d538cf380bfa6f5f5f5be22c5c3d568842bdd9b1bd496544bd7d820392bde7a855a26bcb5ab97d6530561df5629e1a21da38d80913bfd8c49ea5970b1e9")); + check_decrypt(&small(), &h("95d71f562c9e7f65c8802cbff210f27e38760b60e886505a64338c7479d1737e14d2a137f265f21a16745ffa1b93f096288c76dc6c7a8b7cc2c71cd415c7200263347d538cf380bfa6f5f5f5be22c5c3d568842bdd9b1bd496544bd7d820392bde7a855a26bcb5ab97d6530561df5629e1a21da38d80913bfd8c49ea5970b1e9"), false, &h("1"), "-12195486131650044168354063005253372250225651670395170144361492452813796908355947545693884883478244576197260973137312000714301534182408479279674801181219782"); + check_hom(&small(), &h("5739627d60062ca81488631b231bf91d2534596e0278bf63e08c37794b18f8ed42dd5575257b0b04310243fd328fad212af5baeecd441fc08f73f647ea8b44d3e7ba8341266583dc79b50e623609075aea74301c38115f67e6257e97d4f25661dd45ac7ab7c60cbcfd022ac9ed67085ce08cc00ecf2dda8a750eade2f137bdbd"), &h("6713d97c329dcf5443a7ae600b1cf29fb0003d7e556b7c98c3b9c8cbe0c83b8ef4ecf8d2b08bf035e3ba8cc8be77166a77ef8ac800e7d5add25bb980d48b61071f05538cda59e6cfb039b0f99d2d5408dd7758ae9bb68c2f5d6c0115cb6e8e472960f1537d44a0c230295df14b992e01ac93f68b46a342dc5cca7c451043797e"), &h("718ed71459442407951684d08c2b358ba9df2f4c5440db62904fec03471fc1ed12dee8a1b6d60d3e63adafb30b796df37ce31fd73011a9c771f275e9553e506d76608db249247cdc176b8cbf1c929afc4b25e6c789da602ec361a797112f38026aed2f218ac83db008c742c3c85be173c2cb1b799b44bde24b4d41fba0e37d2b"), &h("232ad2867f3f2fe4bd87c8ce546ac71f33eff2ae74a031217e9d9fe751fb93450f59228540101f8b9059815eed3126f1e8608a29ef432727a7cc1892fcae4b1106dffa00d374bb5d341efb7c5ed6fe5d6257095ef6d0b14c3b1c96f6527442ca0c1684c4e37f0ece0563953999ced28108b043965ef6ed70d1a9bbd2dca491aa"), &h("7e497ebcdaf198c46b5190c0db6f991fa934497fb51f6d653724eb487504a28f5e4918e22519349572cb81e3d945d311068b69c7583151074d7a04119048a1ed1969fe9aeffa4663b326003c4c129c1a24a4f7490c9b46065b007065fda2d58692d46c8cecd4ab606349eece366f27d77b21f0032283adcc1b3c70f3cb8bf7c2")); + check_encrypt(&small(), &h("e8da4b63798208f835b544db9cb6928ca9905ce22f75ad71c27e7c16515afd622a85b4c2f66e8a8f7042c746f163567be2295517f644a31c50bbce8ea224d8be"), &h("5"), &h("933b6b111d0ccbb2f82e021487bfffc7352f558700b82293059c8883fbd5655dda4ea30476434d944041927b2435c344be039620a5de9b5ba13e6b4807112f8b6e0306909e89720a1f5e8fd81ae0330816f6aa7e9b05a7958829e5465b248f5d92dd4454848b3d68328478dd6ad1b294df7d17fafa58bce914f09c13603263f7")); + check_encrypt(&small(), &h("e8da4b63798208f835b544db9cb6928ca9905ce22f75ad71c27e7c16515afd622a85b4c2f66e8a8f7042c746f163567be2295517f644a31c50bbce8ea224dbc6"), &h("5"), &h("b7ad3efdb6a8ed0cf65997158aaf89e6bc75218fa22a3da9b6868b6acdb26526c60257e4ffb20737017ccab6ddc93fb8d04f3a74d07f36cd08cfabf97290974c8f9ded18041ffc07578b99d97306ff8766f9734e43852d4bc79ea221acefcbe1a3854928a681f1debcedac4770bd8e269a7a2d73c8c02184ec07387821b82fe4")); + check_encrypt(&small(), &h("1"), &h("5"), &h("c6825c2f43a4b59dfd8eed9bde9203971da47a58f3cbfcda8a9551314132d8bda74a493d5824a6ff99c8a3e29f4fd68f895a5b43eefc25909c2235ccf8b1b71bfa9e4d1574c2719a695d68e1bd94235660cf70042079bc15b136c18d88bc90137a8d07732201478a3ed4245e8b5ab7e4f15901a553157f00ec3d0d81bbf9884a")); + + // ---- Paillier 1024-bit n ---- + // ---- big: n = 520 bit ---- + check_encrypt(&big(), &h("0"), &h("2"), &h("182cea09a5ab199a5a09ffced2fef328c0bc58c88ee20b95eceb1e5e199450c9f7afd35ee4f6e5dbb662528c3fc4335c3896b2a16576f22adedcdd2983e28448ccc41067213177272ef47e7e5dc1830a713cd560b28a72997b358b2498028cb17f96704b72d87f12a30c8fd9172e6c6951ccc016220afcffc1e32de2bf8600c583a476771a94232c207870142242dd10e4382e5406f984da2d72d7b6934d40a12abbbbd634fb3890f717bb6507ac43dd840df3cf0658e286fe74bca30f63d96bd4d3ac12ccbeac6bf33a0b72e51ee834f3132b2cfa4addbca46488a69aefc39fcf96691e780fec54108ffe0c7a5268e56039e8417e6cc0435da24a50c7dd4c17")); + check_decrypt(&big(), &h("182cea09a5ab199a5a09ffced2fef328c0bc58c88ee20b95eceb1e5e199450c9f7afd35ee4f6e5dbb662528c3fc4335c3896b2a16576f22adedcdd2983e28448ccc41067213177272ef47e7e5dc1830a713cd560b28a72997b358b2498028cb17f96704b72d87f12a30c8fd9172e6c6951ccc016220afcffc1e32de2bf8600c583a476771a94232c207870142242dd10e4382e5406f984da2d72d7b6934d40a12abbbbd634fb3890f717bb6507ac43dd840df3cf0658e286fe74bca30f63d96bd4d3ac12ccbeac6bf33a0b72e51ee834f3132b2cfa4addbca46488a69aefc39fcf96691e780fec54108ffe0c7a5268e56039e8417e6cc0435da24a50c7dd4c17"), false, &h("0"), "0"); + check_encrypt(&big(), &h("1"), &h("3"), &h("59ab9b3978dee75df1254176fcea827ca3023860f9d574f6882b05822cfe8581d36ab3d94d2b073871047e49007ddaffd90cd50fa379ce1675642b900ee68775934960c2dfbbc9869ee8d214a0e959d4896bfee402e1f1b49f5f7c77267fac391e7f976eab8a488477a50b2ade6692116c62ca3b18d740943deb91713ccf24ac86ada94d5cd5bad04a6e363cf4b3024fa558c6006be61d2bba9483e93f228a4f4132ffafe1d03304ebc2adbe5151429e919103ee890d69467ef963355202edddd3817d4a455ddc9724ebd6e74c909bd20bbfe8829c74da28c7a22622b505323d0801cfde7944091887fc554441d0393493192f342efd9055c59df8e16fad1b14")); + check_decrypt(&big(), &h("59ab9b3978dee75df1254176fcea827ca3023860f9d574f6882b05822cfe8581d36ab3d94d2b073871047e49007ddaffd90cd50fa379ce1675642b900ee68775934960c2dfbbc9869ee8d214a0e959d4896bfee402e1f1b49f5f7c77267fac391e7f976eab8a488477a50b2ade6692116c62ca3b18d740943deb91713ccf24ac86ada94d5cd5bad04a6e363cf4b3024fa558c6006be61d2bba9483e93f228a4f4132ffafe1d03304ebc2adbe5151429e919103ee890d69467ef963355202edddd3817d4a455ddc9724ebd6e74c909bd20bbfe8829c74da28c7a22622b505323d0801cfde7944091887fc554441d0393493192f342efd9055c59df8e16fad1b14"), false, &h("1"), "1"); + check_encrypt(&big(), &h("1e240"), &h("3039"), &h("75cb7411bc31dbab1ca0e74111e61bdc44f4841021d219317d398c085f1ce96c185cec1475243f10606735d9732b2f21577e026a323125e052d764838b92d54d84cb1616de00f954f0b603a98d9d1fc2a9585285c90e01b7ee6f596b05096d4dc745935b5a0a6570afb27afb85196e09c6b5f21001696b0931ac3834be856b1ae571ebb867be52d05cd55ccc1b0c924d4505f8f70fadc420b49769cb108f1d66f235947740e3caef9ce90475ff2780ec24ff4b11822c1749e430e67747be737482989f1d5cc70047ac901ea177a218df1cf0608afd6ad156e074e32dc5aca5c44b29e651d7f78823ef06a655fffd3c0450271d3af92e661c1d9302d9271bc612")); + check_decrypt(&big(), &h("75cb7411bc31dbab1ca0e74111e61bdc44f4841021d219317d398c085f1ce96c185cec1475243f10606735d9732b2f21577e026a323125e052d764838b92d54d84cb1616de00f954f0b603a98d9d1fc2a9585285c90e01b7ee6f596b05096d4dc745935b5a0a6570afb27afb85196e09c6b5f21001696b0931ac3834be856b1ae571ebb867be52d05cd55ccc1b0c924d4505f8f70fadc420b49769cb108f1d66f235947740e3caef9ce90475ff2780ec24ff4b11822c1749e430e67747be737482989f1d5cc70047ac901ea177a218df1cf0608afd6ad156e074e32dc5aca5c44b29e651d7f78823ef06a655fffd3c0450271d3af92e661c1d9302d9271bc612"), false, &h("1e240"), "123456"); + check_encrypt(&big(), &h("bd8a56b20475a7e9d927fbc445debc8b89d8d06b989c6ff03634e1f8bbc969258a8bae87e5db2a899f6ffbafd5b56d84555c2c6950272124eabcebeded874e3e4b9d92e17d746169341bb3312b36188fe5efe990f9c4fda00ca48a2701a3d76dcc17e3addc7342d98b62c344cc0b08ae930c6d04326eda2bb78e9d1e88819000"), &h("bd8a56b20475a7e9d927fbc445debc8b89d8d06b989c6ff03634e1f8bbc969258a8bae87e5db2a899f6ffbafd5b56d84555c2c6950272124eabcebeded874e3e4b9d92e17d746169341bb3312b36188fe5efe990f9c4fda00ca48a2701a3d76dcc17e3addc7342d98b62c344cc0b08ae930c6d04326eda2bb78e9d1e88818fff"), &h("2b99f80389f4bc6639048873d417016273c35b64eb41a18be83f1c31d3593d8ce30b53b33bc58d349c09f53477cc3698b366529ba236de1699757eb06d3edcb2f1354238542a3b1fceef2671555156dcea73b349bae0aef0f9876ec888b4cbec837aedc8c1d66516fddf4d4b7210f0b390c3499e5d73147d5533f508e89184dc7bfbe6cbc684cffd4864a1cfae31b05116a28894e07380d0b0a48ece632eb82de7fd7f2d15a3ef8720f75176a9f7950d5668f97b25e09642f73c811df30d0e0fbf9e8bf48c8f3b9eacc63f22a3d6595ed403f97bb161113c5a6d4b10b92b2bb96ed12102b3673be94d93c8e063fec5f947b17de3668f4b5bd2d445e12c92d98f")); + check_decrypt(&big(), &h("2b99f80389f4bc6639048873d417016273c35b64eb41a18be83f1c31d3593d8ce30b53b33bc58d349c09f53477cc3698b366529ba236de1699757eb06d3edcb2f1354238542a3b1fceef2671555156dcea73b349bae0aef0f9876ec888b4cbec837aedc8c1d66516fddf4d4b7210f0b390c3499e5d73147d5533f508e89184dc7bfbe6cbc684cffd4864a1cfae31b05116a28894e07380d0b0a48ece632eb82de7fd7f2d15a3ef8720f75176a9f7950d5668f97b25e09642f73c811df30d0e0fbf9e8bf48c8f3b9eacc63f22a3d6595ed403f97bb161113c5a6d4b10b92b2bb96ed12102b3673be94d93c8e063fec5f947b17de3668f4b5bd2d445e12c92d98f"), true, &h("1"), "133099784981468285800789969870330026959610741657712898691611222845656965295432980220407486037856956445197655012201300018235222762930067129696242946251870286620714204256078201186131751030612963407148301258505723115908005564852022451144782745973998227477258914323415053514611999034450379719000891147794576936960"); + check_encrypt(&big(), &h("5ec52b59023ad3f4ec93fde222ef5e45c4ec6835cc4e37f81b1a70fc5de4b492c545d743f2ed9544cfb7fdd7eadab6c22aae1634a8139092755e75f6f6c3a71f25cec970beba30b49a0dd998959b0c47f2f7f4c87ce27ed00652451380d1ebb6e60bf1d6ee39a16cc5b161a2660584574986368219376d15dbc74e8f4440c800"), &h("3f2e1ce6017c8d4df30d53ec174a3ed92df2f023dd897aa56766f5fd93edcdb72e2e8f82a1f3b8d88a7aa93a9c91cf2c1c740ecdc5626061a3944ea4a4826f6a1934864b29d175cdbc093bbb0e675d854ca54ddafdec548aaee1836255e147cf4407f68f497bc0f32e764116eeae583a31042456bb7a48b93d2f89b4d82b3001"), &h("8bad134d57216c47fbab1f7b4f69b9458d66bdedcbd380f125f7f54dba3e25e72c56ac0ff4c7631c26bee5e257b9e41c830e5c4c540b09a392c76ef502ec3556a690c19dfc792c3dd190e10e50fc8ff4d1f6b2db86af430d34673c278fc3a6d4e8e39c003c245437b7bd90aba3f6e5f733f2fc25c73a08d0c8aceeafc17abf9dfe00d0a58f7bc15f28047d40f891bac597683df5480f3556300fb959471d845884b5abebe68ecd1f7563f1412cab52cdde4d8df30102a64ff2a8e802983b65e823a437f39a4193a1dc8481ef708c9c335b7dbc29797531537b0502ca8a2597701de699ffabe842904a01e9d74c3810bdb79b3ee1c73da50d8d93f68c8d7690d")); + check_decrypt(&big(), &h("8bad134d57216c47fbab1f7b4f69b9458d66bdedcbd380f125f7f54dba3e25e72c56ac0ff4c7631c26bee5e257b9e41c830e5c4c540b09a392c76ef502ec3556a690c19dfc792c3dd190e10e50fc8ff4d1f6b2db86af430d34673c278fc3a6d4e8e39c003c245437b7bd90aba3f6e5f733f2fc25c73a08d0c8aceeafc17abf9dfe00d0a58f7bc15f28047d40f891bac597683df5480f3556300fb959471d845884b5abebe68ecd1f7563f1412cab52cdde4d8df30102a64ff2a8e802983b65e823a437f39a4193a1dc8481ef708c9c335b7dbc29797531537b0502ca8a2597701de699ffabe842904a01e9d74c3810bdb79b3ee1c73da50d8d93f68c8d7690d"), false, &h("5ec52b59023ad3f4ec93fde222ef5e45c4ec6835cc4e37f81b1a70fc5de4b492c545d743f2ed9544cfb7fdd7eadab6c22aae1634a8139092755e75f6f6c3a71f25cec970beba30b49a0dd998959b0c47f2f7f4c87ce27ed00652451380d1ebb6e60bf1d6ee39a16cc5b161a2660584574986368219376d15dbc74e8f4440c800"), "66549892490734142900394984935165013479805370828856449345805611422828482647716490110203743018928478222598827506100650009117611381465033564848121473125935143310357102128039100593065875515306481703574150629252861557954002782426011225572391372986999113738629457161707526757305999517225189859500445573897288468480"); + check_encrypt(&big(), &h("5ec52b59023ad3f4ec93fde222ef5e45c4ec6835cc4e37f81b1a70fc5de4b492c545d743f2ed9544cfb7fdd7eadab6c22aae1634a8139092755e75f6f6c3a71f25cec970beba30b49a0dd998959b0c47f2f7f4c87ce27ed00652451380d1ebb6e60bf1d6ee39a16cc5b161a2660584574986368219376d15dbc74e8f4440c801"), &h("bd8a56b20475a7e9d927fbc445debc8b89d8d06b989c6ff03634e1f8bbc969258a8bae87e5db2a899f6ffbafd5b56d84555c2c6950272124eabcebeded874e3e4b9d92e17d746169341bb3312b36188fe5efe990f9c4fda00ca48a2701a3d76dcc17e3addc7342d98b62c344cc0b08ae930c6d04326eda2bb78e9d1e88818ffc"), &h("8ba9593ec2828dff877acb55d7ccd259d8a498d872e61d2dd1b30f4619464aa60698ce04afb72edf51f3552dee4be3b2c6d0af79499d281b69387822f77ffedcda7278418dc0c047af701c8fce8126360e9124f1f89605e909adfc30f6b428d3041806b338aafe123a89fec4d12435eb4f4196548fb88af2802d1b79e63a547a02639160282850623de2b10af12d19d4f0f6cce3b005fe5fc918efed357beb4d5c24dd6c85fcbcf1f641e4c042d9d327185396353d24f3597cd189f92dbe7535be9393aa4c97e6c386d9a052edf42756b483364dbf54546ba5fbac40d83a93f0872876516c03dd86d8fb9cf7ac7d3d2febf5749ac1127923cceaf80f2d260c81")); + check_decrypt(&big(), &h("8ba9593ec2828dff877acb55d7ccd259d8a498d872e61d2dd1b30f4619464aa60698ce04afb72edf51f3552dee4be3b2c6d0af79499d281b69387822f77ffedcda7278418dc0c047af701c8fce8126360e9124f1f89605e909adfc30f6b428d3041806b338aafe123a89fec4d12435eb4f4196548fb88af2802d1b79e63a547a02639160282850623de2b10af12d19d4f0f6cce3b005fe5fc918efed357beb4d5c24dd6c85fcbcf1f641e4c042d9d327185396353d24f3597cd189f92dbe7535be9393aa4c97e6c386d9a052edf42756b483364dbf54546ba5fbac40d83a93f0872876516c03dd86d8fb9cf7ac7d3d2febf5749ac1127923cceaf80f2d260c81"), true, &h("5ec52b59023ad3f4ec93fde222ef5e45c4ec6835cc4e37f81b1a70fc5de4b492c545d743f2ed9544cfb7fdd7eadab6c22aae1634a8139092755e75f6f6c3a71f25cec970beba30b49a0dd998959b0c47f2f7f4c87ce27ed00652451380d1ebb6e60bf1d6ee39a16cc5b161a2660584574986368219376d15dbc74e8f4440c800"), "66549892490734142900394984935165013479805370828856449345805611422828482647716490110203743018928478222598827506100650009117611381465033564848121473125935143310357102128039100593065875515306481703574150629252861557954002782426011225572391372986999113738629457161707526757305999517225189859500445573897288468481"); + check_encrypt(&big(), &h("bd8a56b20475a7e9d927fbc445debc8b89d8d06b989c6ff03634e1f8bbc969258a8bae87e5db2a899f6ffbafd5b56d84555c2c6950272124eabcebeded874e3e4b9d92e17d746169341bb3312b36188fe5efe990f9c4fda00ca48a2701a3d76dcc17e3addc7342d98b62c344cc0b08ae930c6d04326eda2bb78e9d1e88818cf8"), &h("18697"), &h("723682ca7084261eed839356f2a87c9f19e846148a9037b42205150c5a9ac481b9f414efb1173e3a75d35ffc2a2c822920f6826edb653bd0f4fab21e0004e6c441238f12323a8b5702efd16ee9a39688adea56834defe270594349c2b28239d1265c05fe99671fdbe827e3a01883d453ab35793a2f79f5e38b62f3bca6583fffa511ce7df9093389eed323149806117ba6e9b076e9544470f1326f528225973a9083aa5ba948c0b5a1cb7bd868f47dc401cafe690c09a5b53dac99d015ded6c0a933d5abe609d5876ea6af9d441160fe55e16369af9782ddb767967964bc0c24cc19ba5daec459624520998297da3f30175f8c838c6d197895822f34375ced1")); + check_decrypt(&big(), &h("723682ca7084261eed839356f2a87c9f19e846148a9037b42205150c5a9ac481b9f414efb1173e3a75d35ffc2a2c822920f6826edb653bd0f4fab21e0004e6c441238f12323a8b5702efd16ee9a39688adea56834defe270594349c2b28239d1265c05fe99671fdbe827e3a01883d453ab35793a2f79f5e38b62f3bca6583fffa511ce7df9093389eed323149806117ba6e9b076e9544470f1326f528225973a9083aa5ba948c0b5a1cb7bd868f47dc401cafe690c09a5b53dac99d015ded6c0a933d5abe609d5876ea6af9d441160fe55e16369af9782ddb767967964bc0c24cc19ba5daec459624520998297da3f30175f8c838c6d197895822f34375ced1"), true, &h("309"), "-777"); + check_encrypt(&big(), &h("1"), &h("10001"), &h("31f4a9c6c522ebaeca6af7d2392e04265c2193d995d60be5921181855f5018c02713504e72146f2a8f40316db72bfecc70633aeffe261771834b85366df84f428c85b9ee8e467a46354d74bd3562c92cf83850e3d1f99785046da30eba2bd18fde133b932b3b3d7bddbe241015b5581bf3f1b65be40176c03cde92d172911f6c44cb38fda064c779eb7a84a8c9463c0e95334ad74d0f62767dcba9ab126abc6a94cf53eb648d7f8479b2f637f4861abb6b2747a8eb375a5d5b30af75751eca8b40b95607e32e098aa2751e486195738fb3392da568716f874a3139c29050f45c6cff5e8b016f92c5b6e6b03d6dc849282763ad8fc429f97f89fbea45a3667472")); + check_decrypt(&big(), &h("31f4a9c6c522ebaeca6af7d2392e04265c2193d995d60be5921181855f5018c02713504e72146f2a8f40316db72bfecc70633aeffe261771834b85366df84f428c85b9ee8e467a46354d74bd3562c92cf83850e3d1f99785046da30eba2bd18fde133b932b3b3d7bddbe241015b5581bf3f1b65be40176c03cde92d172911f6c44cb38fda064c779eb7a84a8c9463c0e95334ad74d0f62767dcba9ab126abc6a94cf53eb648d7f8479b2f637f4861abb6b2747a8eb375a5d5b30af75751eca8b40b95607e32e098aa2751e486195738fb3392da568716f874a3139c29050f45c6cff5e8b016f92c5b6e6b03d6dc849282763ad8fc429f97f89fbea45a3667472"), false, &h("1"), "-133099784981468285800789969870330026959610741657712898691611222845656965295432980220407486037856956445197655012201300018235222762930067129696242946251870286620714204256078201186131751030612963407148301258505723115908005564852022451144782745973998227477258914323415053514611999034450379719000891147794576936960"); + check_hom(&big(), &h("1248a2e7ec3d4de8e9f6790337f4b19d6ab017a68299e51e8d5ac1d49e35bea0394b2b4077ead7ee194283ad58cf8afa20418d3cb4fc918b192acc2a324d5c26b0d1283b8629ea8aeb55eadb23bf25e92d85475d1db76b3bc5645b3f493777f88121e531224f77c74f1c8ca8f35027ce20d5ced6730e5093ff182f9aead110692cf12207ca64fcf8b4906b3ce95979ed8a2a5533eaf5e83736695bc6bdda4f4028bb90cd183c0b791fbcccf57ee1a218de638488218f6df9c80ab39d99662db829be61818c19253cf0dc83adfbeb3e1adabd5b8704bbd24c017c4bf6cef31c9d74b5ff4857b8eabb39af96c800bae4906cc5a8d93a3fe793a2ce4de5553fcad5"), &h("2f7db6d8f3b0134c37701d5c8fd2c5fbbc83d106812d720b5860bb4489afad1e2780a5ebc46e04ad77fc4ca77bb7dd70840941c340f6522faeadaba0e62656a3524cef4614fad05143e1ae478eef6d7020555f3d9e1151695c39c14b90158603c20bd120981b6108e6f7ac13350b8d8a25988898e10d2710ed35ab98b5f7c617e0006e1aa07f42dc549c00d5352b2ca3abff02e6c53476e1f36e429b6961ba6a8c56d3ceb10ec1d707da7ff52dbb6af25278c184537a3a260630867012d4083aea75cea10a0e95ffb52193e4980dc100e8462ff24641c847dc6b6b2d9c6e2d4257315d3952d2506b176bc146c4eb5320a9542fe805277fe48c5fdc4feabc0b8a"), &h("385582e3ede33a3a070711bc270616cfe27bf8f2500527306fd6e7bdbd39bdf65f4554b56d4f876c2a8cc3a6b52213d12b858bed030aacfa0a3be5c1b266b9453d9cdbbe594856a4b0948335f0518812fff0908ea5110e6a3bf3eab56835c229c5cae7bc01b99d94baeef7e4bc4cd72b3f2cdaee5c2875a2cd24b288fc04435e9892f4848ee6bf362ccc1647d941bf18103a7fc341e4227f1a4b38d1b5957af10f145a91f9ca993f9c94adfd8ebc0785d521102d2b76b3bf3a4647d0769bccafc9720d73a2ec874226edb9a944514a7d52149e1a07e6c07dc4d5abeebd3309d58a364a724363f88c9faac122e45d2eb4c1edbaf0760f5dde932a2bcc8acff083"), &h("3ae10dc10efe04ae9561183accb82b984419b5b208d42d4058efd43b69b802de534a33fc2dd09ec08151e3c9fbaacb48a0f5985266af37ae45a77db039f7a5ff8db0e47dbeea3a45f85f494abdcac142e01601d85569c464ad9392df33a1f6f98e3c8687d59f8fd9afb2810d925b0776598e0286754d0cf74f910d7d3de174aa55615a5e6c504540e1c010e3c5351589f542699059507f5a15d3c7a156d332fa86cc7108be58e48062eafa923b1deed10eb677239134e292ca34869d064efed1340ce3ae1fa9650babf43340c3ef8f75985d26972f354601bb3d2ba569862b898516b32cba04aa2a3a71ea8284941716a106d8c0033d0cf047c118a7d3f0a64d"), &h("78643bc59dbbd4b700b71f9d53178b4087172115f011d758b2eec87301549eb139c1c99a7114b37b593fe1ab8d6d3a6297494d401843e8a27444b4486124b7c6c9c3ed10716d07a12b544509165608466a8b3b37c1e27ba91e9ca1a90ac115e53967320db4e2752b3178a28ec295d3b6bd14d71c118198e6eab62542f5f19006cabf6750c4fd374bb349d7f3db77d599507b8449302c685b0c85c9dd83ca1ca5dbe6cdcca78597fbff8dca1d960b91ff3eb5acfc269d294420a45f346942dcddb0405faa9a5e64a8adc03b58a24ac62cb1ff005b5cabe1bee9f021ff27639aef34ddd270f784ac93381b99982bb186052c93a911db0a6d2ee8e3097b96acd0b6")); + check_encrypt(&big(), &h("bd8a56b20475a7e9d927fbc445debc8b89d8d06b989c6ff03634e1f8bbc969258a8bae87e5db2a899f6ffbafd5b56d84555c2c6950272124eabcebeded874e3e4b9d92e17d746169341bb3312b36188fe5efe990f9c4fda00ca48a2701a3d76dcc17e3addc7342d98b62c344cc0b08ae930c6d04326eda2bb78e9d1e88818cf8"), &h("5"), &h("72463232da7d7ba17bc9554d08b3a5916bac0cbff59e396778b66e963741edf23db3d8e24181be33ae76436bee31b54f2a98478ba55f853676037ba8011da56a33a004720c0679233ae03bc95f10c7020a30aec87fe3af0bfb03a534fc0d3e9e8bfac4628746eafabc0c0978bc7ecc2ee0ad21b11fd112809071e8734692b80a5b8898d03b9e203dfe01492a443cfa9f65b14cb3b1381a3e06ab09bc03889aea04abca2b6489d58e8d99637e1a2cc101665a3b11371ef878cbd41c66ac46d5977a4dde7f2cba726d683c3999f7c59b3c59e34a967f9d0e292ba1762140d7fc6cee13d7267989cecd8851de2743adc93937cd905a2001d827894d47f618171b0e")); + check_encrypt(&big(), &h("bd8a56b20475a7e9d927fbc445debc8b89d8d06b989c6ff03634e1f8bbc969258a8bae87e5db2a899f6ffbafd5b56d84555c2c6950272124eabcebeded874e3e4b9d92e17d746169341bb3312b36188fe5efe990f9c4fda00ca48a2701a3d76dcc17e3addc7342d98b62c344cc0b08ae930c6d04326eda2bb78e9d1e88819000"), &h("5"), &h("56ce9cb99f74a4b0c18a83cbd9b23860e17a6f318fb74a214ba52cb91f8de0d72bb6be3e6e157e45bb320652fb571a4d56347e721fe5857718be6b7b22e343d77fd3194f8b2582fbe423231d5d489a1e5dde7335b6321b1a7f9f3c9f8bac1d92ab26dc13ca67ac44a8db36e3748ef5cd75b54772d804e826e6c318f677ae602c5dd66d59b79a7f373696eb01a9d0f63c139647e531a287f076e8c3c61a25b7f189b345c34a747de220848f097cc44e77799a6087698c77dd1dab32889051d11024b8f658dd8a74e879c1b9808d0d93908ea121eb7d981cc6acd0feeac6f041c7fd9611449f40da4ee47982f015d7c6de95f63d871b59c2a5ea9acc25cb07c3d6")); + check_encrypt(&big(), &h("1"), &h("5"), &h("12bd42b5d748c063004ce26972b649b131139264f79f2c77811b4e68403aae8a281f1048d2697ee665b02d6147179b9d8dfc5974794c3e52966f20720192d57118163b3bb85eaee7b8f93230fd1d184b4e3cc599a789fe637c122bc2c65692e5485f9d55d24e66afb8f959101c502fe967a20ebbf22d71aabfa2fe5f35088b7bb20458fe97838ffc55aa4fc9a7f1d6d1c20153bd4f24e2e3747924c5a39b5118d6033f054925416887776f85199a3b2505a317525dd31c50e7aaaa1e654ae80378eda3f33ce5277da74f250476ed67afdf948d45ebce06f9ebd31d0ff86d75e032122b1e5e65ef7e176a74443d3ada4c5926bec4494c23f8ecbb43e3ae2538b9")); +} diff --git a/crates/nax-he/tests/he_protocol.rs b/crates/nax-he/tests/he_protocol.rs new file mode 100644 index 0000000..a18de7d --- /dev/null +++ b/crates/nax-he/tests/he_protocol.rs @@ -0,0 +1,246 @@ +//! HE 协议语义测试:OLE / 无可信发牌方三元组 / PIR。 +//! +//! 这些测试验证的是**协议数学**(重构后 a·b=c、PIR 查得准), +//! 不是逐位对照 —— 密文带随机因子,每次运行都不同。 +//! 逐位对照在 `golden_paillier.rs` 里。 + +use nax_core::prg::Stream; +use nax_core::ring; +use nax_core::share; +use nax_he::bigint::{BigUint, Signed}; +use nax_he::ole; +use nax_he::paillier::{self, KeyPair, PublicKey}; +use nax_he::pir; +use nax_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 数学上合法"); +} diff --git a/tools/gen_golden.py b/tools/gen_golden.py index aebff94..4fe121f 100644 --- a/tools/gen_golden.py +++ b/tools/gen_golden.py @@ -8,18 +8,19 @@ 而这类 bug 在单元测试里几乎抓不到(测试往往只看"接近")。 所以凡是**确定性**的纯算子,都从参考实现导出一份逐位基线; -Rust 侧用 `assert_eq!` 硬比 u64,不给"误差容忍"留口子。 +Rust 侧用 `assert_eq!` 硬比,不给"误差容忍"留口子。 # 为什么绕开 `import nax` -`nax/__init__.py` 会拉起 pandas 整条链,但 `nax/crypto/ring.py` 只依赖 numpy。 -这里直接用 importlib 按文件加载,保持依赖最小、也避免参考仓库的 -`__init__` 将来变动影响基线生成。 +`nax/__init__.py` 会拉起 pandas 整条链,但 `nax/crypto/ring.py` 与 +`nax/crypto/paillier.py` 只依赖 numpy。这里直接用 importlib 按文件加载, +保持依赖最小、也避免参考仓库的 `__init__` 将来变动影响基线生成。 用法: .venv/bin/python tools/gen_golden.py -输出: - crates/nax-core/tests/golden_vectors.rs +输出: + crates/nax-core/tests/golden_vectors.rs (环算子) + crates/nax-he/tests/golden_paillier.rs (Paillier / 大数) """ from __future__ import annotations @@ -32,10 +33,19 @@ import numpy as np ROOT = pathlib.Path(__file__).resolve().parent.parent REF_RING = ROOT / "refs" / "nax" / "nax" / "crypto" / "ring.py" +REF_PAILLIER = ROOT / "refs" / "nax" / "nax" / "crypto" / "paillier.py" OUT = ROOT / "crates" / "nax-core" / "tests" / "golden_vectors.rs" +OUT_HE = ROOT / "crates" / "nax-he" / "tests" / "golden_paillier.rs" DEFAULT_FXP = 18 +# 固定测试密钥(一次性生成后写死,保证再生成时 diff 稳定)。 +# 仅测试用途 —— 生产密钥必须 keygen 时现生成。 +P512 = 115143333177955593351170883930350830275481352656898832985553126680305234857641 +Q512 = 105915694769767988741462729257215332633525696031712010731853285168725452852463 +P1024 = 13185077936874614465251607502897794108295134688804334693335211059545410538575957469278704721156024331182839602882257300151033818320780324968404181570428423 +Q1024 = 10094728724297416245149492696441592499653382859672861820017232790240265217185766588377851889644878419712866423425923577932070971179003630402571429925806007 + def load_ring(): spec = importlib.util.spec_from_file_location("ref_ring", REF_RING) @@ -45,6 +55,16 @@ def load_ring(): return mod +def load_paillier(): + spec = importlib.util.spec_from_file_location("ref_paillier", REF_PAILLIER) + mod = importlib.util.module_from_spec(spec) + # dataclass 需要模块已注册在 sys.modules 里,否则 _is_type 取不到命名空间 + sys.modules["ref_paillier"] = mod + assert spec.loader is not None + spec.loader.exec_module(mod) + return mod + + def hx(v: int) -> str: """u64 的十六进制字面量。""" return f"0x{v & 0xFFFFFFFFFFFFFFFF:016X}u64" @@ -152,6 +172,95 @@ def emit_colsum(ring) -> list[str]: return lines +def hx_big(v: int) -> str: + """大整数的十六进制字符串字面量。""" + return f'"{v:x}"' + + +# --------------------------------------------------------------------------- # +# Paillier / 大数部分(输出 crates/nax-he/tests/golden_paillier.rs) +# --------------------------------------------------------------------------- # +def emit_bigint() -> list[str]: + """大数 modpow / divmod / mod_inverse 的 Python int 基线。""" + lines = [] + cases_modpow = [ + (2, 10, 1000003), + (123456, 1000, 1000003), + ((1 << 200) + 5, (1 << 97) + 3, (1 << 130) + 77), + (0xDEADBEEFCAFEBABE, (1 << 70) + 1, (1 << 160) + 21), + ] + for base, exp, m in cases_modpow: + want = pow(base, exp, m) + lines.append( + f' assert_eq!(h({hx_big(base)}).modpow(&h({hx_big(exp)}), &h({hx_big(m)}))' + f'.unwrap().to_hex(), {hx_big(want)}.to_string(), "modpow");' + ) + cases_divmod = [ + ((1 << 200) + 12345, (1 << 97) + 77), + (0xFFFFFFFFFFFFFFFFFFFF, 7), + ((1 << 128) - 1, (1 << 64) - 3), + ] + for a, d in cases_divmod: + q, r = divmod(a, d) + lines.append( + f' {{ let (q, r) = h({hx_big(a)}).divmod(&h({hx_big(d)})).unwrap(); ' + f'assert_eq!(q.to_hex(), {hx_big(q)}.to_string(), "divmod q"); ' + f'assert_eq!(r.to_hex(), {hx_big(r)}.to_string(), "divmod r"); }}' + ) + cases_inv = [(3, 1000003), (77, 1000003), ((1 << 80) + 5, (1 << 89) - 1)] # 2^89-1 是梅森素数 + for a, m in cases_inv: + want = pow(a, -1, m) + lines.append( + f' assert_eq!(h({hx_big(a)}).mod_inverse(&h({hx_big(m)}))' + f'.unwrap().to_hex(), {hx_big(want)}.to_string(), "mod_inverse");' + ) + return lines + + +def emit_paillier_cases(pai, p: int, q: int, tag: str) -> list[str]: + """确定性 Paillier 算子:encrypt(m, r) / decrypt_signed / add / mul_plain。 + + 全部显式指定随机因子 r,密文确定性 —— 这就是能做逐位对照的原因。 + """ + n = p * q + pub = pai.PublicKey(n) + priv = pai.PrivateKey(pub, p, q) + lines = [f" // ---- {tag}: n = {n.bit_count()} bit ----"] + + # encrypt(m, r) + decrypt_signed 往返(含负明文与 n//2 边界) + ms = [0, 1, 123456, n - 1, n // 2, n // 2 + 1, -777, -(n - 1)] + rs = [2, 3, 12345, n - 2, (n // 3) + 1, n - 5, 99991, 65537] + for m, r in zip(ms, rs): + c = pub.encrypt(m, r) # Python 内部 m %= n(向下取整) + lines.append( + f' check_encrypt(&{tag}(), &h({hx_big(m % n)}), &h({hx_big(r)}), &h({hx_big(c)}));' + ) + dec = priv.decrypt_signed(c) + want_neg = dec < 0 + want_mag = abs(dec) + lines.append( + f' check_decrypt(&{tag}(), &h({hx_big(c)}), {str(want_neg).lower()}, ' + f'&h({hx_big(want_mag)}), "{m}");' + ) + + # 同态链:add / add_plain / mul_plain(密文确定 → 结果确定) + c1 = pub.encrypt(300, 7) + c2 = pub.encrypt(45, 11) + lines.append( + f' check_hom(&{tag}(), &h({hx_big(c1)}), &h({hx_big(c2)}), ' + f'&h({hx_big(pub.add(c1, c2))}), &h({hx_big(pub.add_plain(c1, 17))}), ' + f'&h({hx_big(pub.mul_plain(c2, 2))}));' + ) + # 负明文编码(Python 的 m %= n 向下取整语义) + for m in (-777, -1, -(n - 1)): + r = 5 + c = pub.encrypt(m, r) + lines.append( + f' check_encrypt(&{tag}(), &h({hx_big(m % n)}), &h({hx_big(r)}), &h({hx_big(c)}));' + ) + return lines + + def main() -> int: ring = load_ring() body: list[str] = [] @@ -231,5 +340,108 @@ fn conformance_with_python_reference() {{ return 0 +def main_he() -> int: + """生成 crates/nax-he/tests/golden_paillier.rs。""" + pai = load_paillier() + body: list[str] = [] + body += [" // ---- bigint: modpow / divmod / mod_inverse ----"] + body += emit_bigint() + body += ["", " // ---- Paillier 512-bit n ----"] + body += emit_paillier_cases(pai, P512, Q512, "small") + body += ["", " // ---- Paillier 1024-bit n ----"] + body += emit_paillier_cases(pai, P1024, Q1024, "big") + + n_cases = sum(1 for line in body if line.strip().startswith(("check_", "assert_eq!", "{ let"))) + + header = f'''//! **自动生成,请勿手改。** +//! +//! 由 `tools/gen_golden.py` 从参考实现 `refs/nax/nax/crypto/paillier.py` 导出。 +//! 用例数:{n_cases} +//! +//! 重新生成: +//! ```bash +//! .venv/bin/python tools/gen_golden.py +//! ``` +//! +//! 这个文件的意义:Rust 的 Paillier 与 Python 参考实现必须给出**逐位相同** +//! 的密文与解密结果(给定相同明文与随机因子 r)。一旦某次改动让这里变红, +//! 说明语义漂移了 —— 不要去"放宽断言",先确认哪一边才是对的。 + +#![allow(clippy::unreadable_literal)] + +use nax_core::prg::Stream; +use nax_he::bigint::{{BigUint, Signed}}; +use nax_he::paillier::{{KeyPair, PrivateKey, PublicKey}}; + +fn h(s: &str) -> BigUint {{ + BigUint::from_hex(s).unwrap() +}} + +fn dead_stream() -> Stream {{ + Stream::new(&[0u8; 32]) +}} + +fn build_kp(p: &str, q: &str) -> KeyPair {{ + let (p, q) = (h(p), h(q)); + let pubk = PublicKey::new(p.mul(&q)).unwrap(); + let privk = PrivateKey::new(pubk.clone(), p, q).unwrap(); + KeyPair {{ public: pubk, private: privk }} +}} + +fn small() -> KeyPair {{ + build_kp("{P512:x}", "{Q512:x}") +}} + +fn big() -> KeyPair {{ + build_kp("{P1024:x}", "{Q1024:x}") +}} + +/// encrypt(m, r) 逐位对照(r 显式给定 → 密文确定性)。 +fn check_encrypt(kp: &KeyPair, m: &BigUint, r: &BigUint, want: &BigUint) {{ + let c = kp.public.encrypt(m, Some(r), &mut dead_stream()).unwrap(); + assert_eq!(c.to_hex(), want.to_hex(), "encrypt(m={{}}, r={{}})", m.to_hex(), r.to_hex()); +}} + +/// decrypt_signed 逐位对照。 +fn check_decrypt(kp: &KeyPair, c: &BigUint, want_neg: bool, want_mag: &BigUint, label: &str) {{ + let s = kp.private.decrypt_signed(c); + assert_eq!(s.neg, want_neg, "decrypt_signed({{}}).neg", label); + assert_eq!(s.mag.to_hex(), want_mag.to_hex(), "decrypt_signed({{}}).mag", label); +}} + +/// 同态算子逐位对照:add(c1,c2) / add_plain(c1,17) / mul_plain(c2,2)。 +fn check_hom( + kp: &KeyPair, + c1: &BigUint, + c2: &BigUint, + want_add: &BigUint, + want_add_plain: &BigUint, + want_mul_plain: &BigUint, +) {{ + assert_eq!(kp.public.add(c1, c2).to_hex(), want_add.to_hex(), "add"); + assert_eq!(kp.public.add_plain(c1, &BigUint::from_u64(17)).to_hex(), want_add_plain.to_hex(), "add_plain"); + assert_eq!( + kp.public.mul_plain(c2, &BigUint::from_u64(2)).unwrap().to_hex(), + want_mul_plain.to_hex(), + "mul_plain" + ); + let _ = Signed::from_i64(0); // 保持 use 引用 +}} + +#[test] +fn conformance_with_python_reference() {{ +{chr(10).join(body)} +}} +''' + + OUT_HE.parent.mkdir(parents=True, exist_ok=True) + OUT_HE.write_text(header, encoding="utf-8") + print(f"wrote {OUT_HE.relative_to(ROOT)} ({n_cases} cases)") + return 0 + + if __name__ == "__main__": - sys.exit(main()) + rc = main() + if rc == 0: + rc = main_he() + sys.exit(rc)