feat: P4 大数 Paillier + HE-OLE —— 无可信发牌方的 Beaver 物料
- 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 全通过
This commit is contained in:
1 parent
7b373fb0d8
commit
5d385ccd60
14 files changed
+2493
-22
No files matched your search
Generated
+7
@@ -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"
|
||||
|
||||
@@ -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<j} (aᵢbⱼ + aⱼbᵢ)
|
||||
```
|
||||
|
||||
每对参与方做两次 OLE,发起方拿 `aᵢbⱼ − t`、响应方拿 `t`,没有任何实体
|
||||
见过 `a` 或 `b` 的真值。输出布局与 `share::mul_triple_into` 完全一致,
|
||||
可以直接喂给 `nax-vault` 在线阶段。对应参考实现的 `Vault(triples="he")`。
|
||||
|
||||
- `bigint`:手写大整数(Montgomery 模幂 / Knuth D 除法 / Miller-Rabin),零外部依赖
|
||||
- `paillier`:与 Python **逐位一致**(50 条 golden:显式 `r` 的密文、解密、
|
||||
同态链、负明文的 `%` 向下取整语义、`n//2` 边界)
|
||||
- `ole` / `pir` / `triple`:OLE 响应、1-out-of-N 隐匿查询、n 方三元组协商
|
||||
(2 方 / 3 方 / 矩阵版语义测试全绿)
|
||||
|
||||
```bash
|
||||
cargo test -p nax-he # 23 用例
|
||||
cargo test --release -p nax-he --test bench_he -- --ignored --nocapture
|
||||
```
|
||||
|
||||
已知边界:与参考实现同级的**非常数时间**实现(私钥操作生产放 TEE);
|
||||
HE 物料给不出截断对(`(r, r>>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/ 参考实现(独立仓库,仅作基线)
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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"]
|
||||
@@ -0,0 +1,925 @@
|
||||
//! 大整数算术 —— Paillier 的运算地基。
|
||||
//!
|
||||
//! # 为什么自己写而不是引 num-bigint
|
||||
//!
|
||||
//! 项目铁律是"不过多依赖":`nax-core` 零依赖,`curve25519-dalek` 是
|
||||
//! 唯一例外(恒定时间约束,手写会被时序侧信道打穿)。大数运算没有这个
|
||||
//! 约束 —— 参考实现自己都声明"未做常数时间保护",生产部署把私钥操作
|
||||
//! 放 TEE 里。于是这里手写一份 ~700 行的实现:`alloc::vec::Vec<u64>`
|
||||
//! 小端 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<u64>,
|
||||
}
|
||||
|
||||
/// 大整数错误。
|
||||
#[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<u8> {
|
||||
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<Self, BigIntError> {
|
||||
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<Self> {
|
||||
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<Self, BigIntError> {
|
||||
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<Self, BigIntError> {
|
||||
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<u64>,
|
||||
m0inv: u64,
|
||||
r2: Vec<u64>,
|
||||
}
|
||||
|
||||
impl MontCtx {
|
||||
/// 为奇数模数 `m` 建上下文。
|
||||
pub fn new(m: &BigUint) -> Result<Self, BigIntError> {
|
||||
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<u64> {
|
||||
self.mul_raw(a, &self.r2)
|
||||
}
|
||||
|
||||
/// Montgomery 表示 → 普通表示(`a * R⁻¹ mod m`)。
|
||||
fn from_mont(&self, a: &[u64]) -> Vec<u64> {
|
||||
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<u64> {
|
||||
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<u64>> = 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<u64> {
|
||||
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));
|
||||
}
|
||||
}
|
||||
@@ -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};
|
||||
@@ -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<Vec<BigUint>, 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<u64> {
|
||||
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<Vec<BigUint>, 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<Vec<BigUint>, 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<BigUint> = 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)
|
||||
}
|
||||
@@ -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<BigIntError> 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<Self, HeError> {
|
||||
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<BigUint, HeError> {
|
||||
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<BigUint, HeError> {
|
||||
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<BigUint, HeError> {
|
||||
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<BigUint, HeError> {
|
||||
let e = k.py_mod(&self.n);
|
||||
Ok(self.mont.modpow(c, &e))
|
||||
}
|
||||
|
||||
/// 逐元素加密。
|
||||
pub fn encrypt_vec(&self, ms: &[BigUint], s: &mut Stream) -> Result<Vec<BigUint>, 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<BigUint>]) -> Vec<BigUint> {
|
||||
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<Self, HeError> {
|
||||
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<Signed> {
|
||||
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<KeyPair, HeError> {
|
||||
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;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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<Vec<BigUint>, 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<BigUint, HeError> {
|
||||
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)
|
||||
}
|
||||
@@ -0,0 +1,266 @@
|
||||
//! 无可信发牌方的 Beaver 三元组(HE-OLE 协商)。
|
||||
//!
|
||||
//! 对齐 `refs/nax/nax/device/offline.py` 的 `HESource._negotiate`:
|
||||
//!
|
||||
//! ```text
|
||||
//! (Σaᵢ)(Σbᵢ) = Σᵢ aᵢbᵢ + Σ_{i<j} (aᵢbⱼ + aⱼbᵢ)
|
||||
//! ```
|
||||
//!
|
||||
//! 左边的本地项各方自己算;右边每一对做两次 OLE —— 发起方拿到
|
||||
//! `aᵢbⱼ − t`、响应方拿到 `t`,加起来正好补齐。**没有任何实体见过
|
||||
//! `a` 或 `b` 的真值**,可信发牌方这一条信任假设被整个删掉。
|
||||
//!
|
||||
//! # 与 `nax_core::share::Dealer` 的关系
|
||||
//!
|
||||
//! [`mul_triple_into`] / [`matmul_triple_into`] 的输出布局与
|
||||
//! `share::mul_triple_into` / `share::matmul_triple_into` **完全一致**
|
||||
//! (平铺 `shares[party * len + i]`),可以直接喂给 `nax-vault` 的
|
||||
//! 在线阶段。区别只在物料怎么来:
|
||||
//!
|
||||
//! | | Dealer | HE-OLE(这里) |
|
||||
//! |---|---|---|
|
||||
//! | 信任假设 | 半诚实第三方 | 无第三方 |
|
||||
//! | 速度 | 纯 PRG,微秒级 | 每元素数次公钥运算 |
|
||||
//! | 截断对 | 支持 | **不支持**(非线性关联给不出,退化本地右移) |
|
||||
//!
|
||||
//! # 内存内模拟
|
||||
//!
|
||||
//! 这里的 `master` 派生出每方的密钥与随机数,把 n 方协议在单进程里
|
||||
//! 跑完 —— 用于验证协议数学。分布式执行(每方一进程、密钥不出方)
|
||||
//! 由 `nax-node` 驱动同样的纯函数 [`crate::ole`],消息走帧协议。
|
||||
//! 数学完全相同,差别只是谁能看到中间态。
|
||||
|
||||
use alloc::vec;
|
||||
use alloc::vec::Vec;
|
||||
|
||||
use nax_core::prg::Stream;
|
||||
use nax_core::ring;
|
||||
|
||||
use crate::ole;
|
||||
use crate::paillier::{self, HeError};
|
||||
|
||||
/// HE 物料的默认 Paillier 模数位数(与参考实现 `HESource(bits=512)` 一致)。
|
||||
///
|
||||
/// 512 位模数跑通逻辑足够(中间量最大 2^128,远不会回绕 `Z_N`);
|
||||
/// 真要防谁上 2048 —— 慢约 30 倍。
|
||||
pub const DEFAULT_HE_BITS: usize = 512;
|
||||
|
||||
/// 从主种子派生子流(每方、每用途一条,杜绝随机流复用)。
|
||||
fn derive(master: &[u8; 32], label: &[u8]) -> 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<u64>> = Vec::with_capacity(n);
|
||||
let mut b: Vec<Vec<u64>> = 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<u64>> = 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<u64>> = Vec::with_capacity(n);
|
||||
let mut b: Vec<Vec<u64>> = 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<u64>> = 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<u8> {
|
||||
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<u8> {
|
||||
let mut l = party_label(tag, i);
|
||||
l.extend_from_slice(&(j as u32).to_le_bytes());
|
||||
l
|
||||
}
|
||||
@@ -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<BigUint> = (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<u64> = (0..64).map(|i| i * 7919).collect();
|
||||
let v: Vec<u64> = (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());
|
||||
}
|
||||
@@ -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"));
|
||||
}
|
||||
@@ -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 数学上合法");
|
||||
}
|
||||
+219
-7
@@ -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)
|
||||
Reference in new issue
Block a user