ci / gate (push) Waiting to run
- 项目与文档标题:nax-rs → ssw-mpc(尚数网-多方安全计算),二进制 nax → mpc - 18 个 crate 及目录 nax-* → mpc-*,Rust 引用 nax_* → mpc_* - 环境变量、C 符号、构建/部署脚本:NAX_* → MPC_*、libnax_ray.so → libmpc_ray.so - 保留协议域分隔常量与 refs/nax 参考实现路径,维持 golden 向量与历史数据兼容 - 新增 [profile.dev] incremental=false
487 lines
15 KiB
Rust
487 lines
15 KiB
Rust
//! n 方加性秘密分享与离线物料。
|
||
//!
|
||
//! # 语义
|
||
//!
|
||
//! 秘密 `x` 拆成 `n` 份 `x_1..x_n`,满足 `Σ x_i ≡ x (mod 2^64)`。
|
||
//! 任意 `n-1` 份在环上均匀随机 —— 这是**信息论安全**,
|
||
//! 不依赖任何计算假设,也不依赖对手算力。
|
||
//!
|
||
//! # 内存布局(重要)
|
||
//!
|
||
//! 所有涉及多方的缓冲用**平铺布局**:`shares[party * len + i]`。
|
||
//! 这么设计是因为 `no_std` 零分配下没法返回 `Vec<&mut [u64]>`,
|
||
//! 而嵌套 `&mut [&mut [u64]]` 又让调用方很难传。平铺布局还顺带一个好处:
|
||
//! 整个 share 集合是一块连续内存,可以直接原样塞进网络帧发出。
|
||
//!
|
||
//! # 离线物料的信任模型
|
||
//!
|
||
//! [`Dealer`] 是半诚实可信第三方:只产**与数据无关**的随机物料,
|
||
//! 不接触任何一方的真实输入。要消除这个假设,得换成 Paillier-OLE
|
||
//! 或 OT 扩展(参考实现的 `triples="he"` 走的就是这条),
|
||
//! 那是 `mpc-he` crate 的事,不在算子核里。
|
||
|
||
use alloc::vec;
|
||
|
||
use crate::prg::Stream;
|
||
use crate::ring::{self, RING_BITS};
|
||
use crate::{MpcError, Result};
|
||
|
||
/// 单次处理的最大元素数(栈上临时缓冲上限)。
|
||
///
|
||
/// 故意取小值:TA 栈通常只有 8~32 KB,算子核不能假设调用方有无限栈。
|
||
const CHUNK: usize = 64;
|
||
|
||
/// 平铺布局下第 `party` 方分片的起点。
|
||
#[inline]
|
||
pub const fn share_offset(party: usize, len: usize) -> usize {
|
||
party * len
|
||
}
|
||
|
||
/// 分片核心:`v` 的 n 份分享通过 `put(p, off, slice)` 逐个交出。
|
||
///
|
||
/// `off` 是这一块在整体中的偏移 —— 调用方必须把它算进目标下标,
|
||
/// 否则跨 `CHUNK` 的多块会互相覆盖(这个 bug 只在 len > 64 时出现)。
|
||
/// 只用一个 `CHUNK` 大小的累加器,因此对任意 `n` 都不额外占栈。
|
||
fn split_parts<F>(
|
||
v: &[u64],
|
||
n: usize,
|
||
s: &mut Stream,
|
||
fxp: u32,
|
||
mut put: F,
|
||
) -> Result<()>
|
||
where
|
||
F: FnMut(usize, usize, &[u64]) -> Result<()>,
|
||
{
|
||
if n < 2 {
|
||
return Err(MpcError::TooFewParties);
|
||
}
|
||
let len = v.len();
|
||
let mut acc = [0u64; CHUNK];
|
||
let mut tmp = [0u64; CHUNK];
|
||
let mut off = 0;
|
||
while off < len {
|
||
let take = core::cmp::min(CHUNK, len - off);
|
||
// acc 初始为 v,逐份减去随机数,最后剩下的就是"最后一份"
|
||
acc[..take].copy_from_slice(&v[off..off + take]);
|
||
|
||
for p in 0..n - 1 {
|
||
let r = &mut tmp[..take];
|
||
s.fill_u64_fxp(r, fxp);
|
||
put(p, off, r)?;
|
||
for (a, rv) in acc[..take].iter_mut().zip(r.iter()) {
|
||
*a = a.wrapping_sub(*rv);
|
||
}
|
||
}
|
||
put(n - 1, off, &acc[..take])?;
|
||
off += take;
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
/// 把 `v` 拆成 `n` 份加性分享,写入平铺缓冲 `out`(长度须 `>= n * v.len()`)。
|
||
///
|
||
/// `fxp > 0` 时噪声缩到 `fxp` 尺度(等价于参考实现的 `split(fxp=...)`),
|
||
/// 防止链式 matmul 把数值推到 64 位满量程后溢出。
|
||
pub fn split_into(v: &[u64], n: usize, s: &mut Stream, out: &mut [u64], fxp: u32) -> Result<()> {
|
||
let len = v.len();
|
||
if out.len() < n * len {
|
||
return Err(MpcError::BufferTooSmall);
|
||
}
|
||
split_parts(v, n, s, fxp, |p, off, slice| {
|
||
let base = p * len + off;
|
||
out[base..base + slice.len()].copy_from_slice(slice);
|
||
Ok(())
|
||
})
|
||
}
|
||
|
||
/// 从平铺缓冲重建(`n` 份求和)。
|
||
pub fn reconstruct_into(shares: &[u64], n: usize, len: usize, out: &mut [u64]) -> Result<()> {
|
||
if shares.len() < n * len {
|
||
return Err(MpcError::ShapeMismatch);
|
||
}
|
||
if out.len() < len {
|
||
return Err(MpcError::BufferTooSmall);
|
||
}
|
||
out[..len].copy_from_slice(&shares[..len]);
|
||
for p in 1..n {
|
||
let src = &shares[p * len..(p + 1) * len];
|
||
for (o, s) in out[..len].iter_mut().zip(src.iter()) {
|
||
*o = o.wrapping_add(*s);
|
||
}
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
/// Beaver 三元组(逐元素乘):`a * b = c` 的三方分享。
|
||
///
|
||
/// 调用方给三块平铺缓冲,各自长度 `>= n * len`。
|
||
pub fn mul_triple_into(
|
||
n: usize,
|
||
len: usize,
|
||
fxp: u32,
|
||
s: &mut Stream,
|
||
a_sh: &mut [u64],
|
||
b_sh: &mut [u64],
|
||
c_sh: &mut [u64],
|
||
) -> Result<()> {
|
||
if a_sh.len() < n * len || b_sh.len() < n * len || c_sh.len() < n * len {
|
||
return Err(MpcError::BufferTooSmall);
|
||
}
|
||
let mut a = [0u64; CHUNK];
|
||
let mut b = [0u64; CHUNK];
|
||
let mut c = [0u64; CHUNK];
|
||
let mut off = 0;
|
||
while off < len {
|
||
let take = core::cmp::min(CHUNK, len - off);
|
||
let (as_, bs, cs) = (&mut a[..take], &mut b[..take], &mut c[..take]);
|
||
s.fill_u64_fxp(as_, fxp);
|
||
s.fill_u64_fxp(bs, fxp);
|
||
ring::mul_into(as_, bs, cs)?;
|
||
|
||
// 三块各自按「第 p 份」写进平铺目标
|
||
split_parts(as_, n, s, fxp, |p, o, sl| {
|
||
let base = p * len + o;
|
||
a_sh[base..base + sl.len()].copy_from_slice(sl);
|
||
Ok(())
|
||
})?;
|
||
split_parts(bs, n, s, fxp, |p, o, sl| {
|
||
let base = p * len + o;
|
||
b_sh[base..base + sl.len()].copy_from_slice(sl);
|
||
Ok(())
|
||
})?;
|
||
split_parts(cs, n, s, fxp, |p, o, sl| {
|
||
let base = p * len + o;
|
||
c_sh[base..base + sl.len()].copy_from_slice(sl);
|
||
Ok(())
|
||
})?;
|
||
off += take;
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
/// 矩阵 Beaver 三元组:`A (rows×k)`, `B (k×cols)`, `C = A·B (rows×cols)`。
|
||
///
|
||
/// 与逐元素三元组的区别:`C` 不是逐元素积,而是真正的矩阵乘。
|
||
/// 在线阶段的标准公式(Beaver, EUROCRYPT'91):
|
||
///
|
||
/// ```text
|
||
/// d = X − A (打开) e = W − B (打开)
|
||
/// Z_i = C_i + d·B_i + A_i·e (+ d·e 仅 i=0)
|
||
/// ```
|
||
pub fn matmul_triple_into(
|
||
n: usize,
|
||
rows: usize,
|
||
k: usize,
|
||
cols: usize,
|
||
fxp: u32,
|
||
s: &mut Stream,
|
||
a_sh: &mut [u64],
|
||
b_sh: &mut [u64],
|
||
c_sh: &mut [u64],
|
||
) -> Result<()> {
|
||
let a_len = rows * k;
|
||
let b_len = k * cols;
|
||
let c_len = rows * cols;
|
||
if a_sh.len() < n * a_len || b_sh.len() < n * b_len || c_sh.len() < n * c_len {
|
||
return Err(MpcError::BufferTooSmall);
|
||
}
|
||
|
||
// 生成 A, B(固定点尺度的随机数)
|
||
let mut a = vec![0u64; a_len];
|
||
let mut b = vec![0u64; b_len];
|
||
s.fill_u64_fxp(&mut a, fxp);
|
||
s.fill_u64_fxp(&mut b, fxp);
|
||
|
||
// C = A · B(u64 硬环上的矩阵乘)
|
||
let mut c = vec![0u64; c_len];
|
||
ring::matmul_into(rows, k, cols, &a, &b, &mut c)?;
|
||
|
||
// 三块各自拆 n 份
|
||
split_parts(&a, n, s, fxp, |p, o, sl| {
|
||
let base = p * a_len + o;
|
||
a_sh[base..base + sl.len()].copy_from_slice(sl);
|
||
Ok(())
|
||
})?;
|
||
split_parts(&b, n, s, fxp, |p, o, sl| {
|
||
let base = p * b_len + o;
|
||
b_sh[base..base + sl.len()].copy_from_slice(sl);
|
||
Ok(())
|
||
})?;
|
||
split_parts(&c, n, s, fxp, |p, o, sl| {
|
||
let base = p * c_len + o;
|
||
c_sh[base..base + sl.len()].copy_from_slice(sl);
|
||
Ok(())
|
||
})?;
|
||
Ok(())
|
||
}
|
||
|
||
/// 截断对 `(r, r >> fxp)`,用于乘法后的定点缩放。
|
||
///
|
||
/// 两块的 `r` 必须是**同一个随机值**,否则在线阶段的
|
||
/// `(x + r) >> fxp - (r >> fxp)` 会引入额外误差。
|
||
pub fn trunc_pair_into(
|
||
n: usize,
|
||
len: usize,
|
||
fxp: u32,
|
||
s: &mut Stream,
|
||
r_sh: &mut [u64],
|
||
rt_sh: &mut [u64],
|
||
) -> Result<()> {
|
||
if r_sh.len() < n * len || rt_sh.len() < n * len {
|
||
return Err(MpcError::BufferTooSmall);
|
||
}
|
||
let mut r = [0u64; CHUNK];
|
||
let mut rt = [0u64; CHUNK];
|
||
let mut off = 0;
|
||
while off < len {
|
||
let take = core::cmp::min(CHUNK, len - off);
|
||
s.fill_u64(&mut r[..take]);
|
||
ring::arshift_into(&r[..take], fxp, &mut rt[..take])?;
|
||
split_parts(&r[..take], n, s, fxp, |p, o, sl| {
|
||
let base = p * len + o;
|
||
r_sh[base..base + sl.len()].copy_from_slice(sl);
|
||
Ok(())
|
||
})?;
|
||
split_parts(&rt[..take], n, s, fxp, |p, o, sl| {
|
||
let base = p * len + o;
|
||
rt_sh[base..base + sl.len()].copy_from_slice(sl);
|
||
Ok(())
|
||
})?;
|
||
off += take;
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
/// edaBit:随机环元素 `r` 的 **64 个共享比特**。
|
||
///
|
||
/// 布局:`out[bit * (n*len) + party * len + i]`。
|
||
///
|
||
/// 为什么 edaBit 是安全比较的地基:`r` 由 64 个独立均匀比特拼成,
|
||
/// 因此 `r` 在 `Z_2^64` 上**严格均匀**。在线阶段打开 `c = x + r` 时,
|
||
/// `c` 与 `x` 统计独立 —— 这是完美隐藏,不依赖任何有界性假设。
|
||
pub fn edabit_into(n: usize, len: usize, s: &mut Stream, out: &mut [u64]) -> Result<()> {
|
||
let stride = n * len;
|
||
if out.len() < RING_BITS as usize * stride {
|
||
return Err(MpcError::BufferTooSmall);
|
||
}
|
||
let mut bits = [0u64; CHUNK];
|
||
let mut off = 0;
|
||
while off < len {
|
||
let take = core::cmp::min(CHUNK, len - off);
|
||
for bit in 0..RING_BITS as usize {
|
||
for b in bits[..take].iter_mut() {
|
||
let mut byte = [0u8; 1];
|
||
s.fill_bytes(&mut byte);
|
||
*b = (byte[0] & 1) as u64;
|
||
}
|
||
split_parts(&bits[..take], n, s, 0, |p, o, sl| {
|
||
let base = bit * stride + p * len + o;
|
||
out[base..base + sl.len()].copy_from_slice(sl);
|
||
Ok(())
|
||
})?;
|
||
}
|
||
off += take;
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
/// 离线物料发牌方。持有主种子,确定性地产出所有随机物料。
|
||
///
|
||
/// 生产部署里 `master` 应由 TEE 派生(设备绑定密钥 + 会话 nonce),
|
||
/// 见 `mpc-tee`。发牌方自己重启后无法重放历史物料 —— 这是特性不是缺陷。
|
||
pub struct Dealer {
|
||
master: [u8; 32],
|
||
n: usize,
|
||
fxp: u32,
|
||
seq: u64,
|
||
}
|
||
|
||
impl Dealer {
|
||
/// 新建发牌方。
|
||
pub fn new(master: [u8; 32], n_parties: usize, fxp: u32) -> Self {
|
||
Self { master, n: n_parties, fxp, seq: 0 }
|
||
}
|
||
|
||
/// 参与方数量。
|
||
pub fn parties(&self) -> usize {
|
||
self.n
|
||
}
|
||
|
||
/// 定点点数位。
|
||
pub fn fxp(&self) -> u32 {
|
||
self.fxp
|
||
}
|
||
|
||
fn next_stream(&mut self, tag: &[u8]) -> Stream {
|
||
let mut label = [0u8; 16];
|
||
let n = core::cmp::min(tag.len(), 8);
|
||
label[..n].copy_from_slice(&tag[..n]);
|
||
label[8..].copy_from_slice(&self.seq.to_le_bytes());
|
||
self.seq = self.seq.wrapping_add(1);
|
||
Stream::derive(&self.master, &label)
|
||
}
|
||
|
||
/// 生成一组逐元素乘三元组,写入调用方缓冲。
|
||
pub fn mul_triple(
|
||
&mut self,
|
||
len: usize,
|
||
a_sh: &mut [u64],
|
||
b_sh: &mut [u64],
|
||
c_sh: &mut [u64],
|
||
) -> Result<()> {
|
||
let mut s = self.next_stream(b"triple");
|
||
let (n, fxp) = (self.n, self.fxp);
|
||
mul_triple_into(n, len, fxp, &mut s, a_sh, b_sh, c_sh)
|
||
}
|
||
|
||
/// 生成一组矩阵 Beaver 三元组。
|
||
pub fn matmul_triple(
|
||
&mut self,
|
||
rows: usize,
|
||
k: usize,
|
||
cols: usize,
|
||
a_sh: &mut [u64],
|
||
b_sh: &mut [u64],
|
||
c_sh: &mut [u64],
|
||
) -> Result<()> {
|
||
let mut s = self.next_stream(b"mattriple");
|
||
let (n, fxp) = (self.n, self.fxp);
|
||
matmul_triple_into(n, rows, k, cols, fxp, &mut s, a_sh, b_sh, c_sh)
|
||
}
|
||
|
||
/// 生成一组截断对。
|
||
pub fn trunc_pair(&mut self, len: usize, r_sh: &mut [u64], rt_sh: &mut [u64]) -> Result<()> {
|
||
let mut s = self.next_stream(b"trunc");
|
||
let (n, fxp) = (self.n, self.fxp);
|
||
trunc_pair_into(n, len, fxp, &mut s, r_sh, rt_sh)
|
||
}
|
||
|
||
/// 生成一组 edaBit。
|
||
pub fn edabit(&mut self, len: usize, out: &mut [u64]) -> Result<()> {
|
||
let mut s = self.next_stream(b"edabit");
|
||
let n = self.n;
|
||
edabit_into(n, len, &mut s, out)
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
|
||
fn stream() -> Stream {
|
||
Stream::new(&[42u8; 32])
|
||
}
|
||
|
||
#[test]
|
||
fn split_reconstruct_roundtrip() {
|
||
let v: Vec<u64> = (0..100).map(|i| (i as u64).wrapping_mul(0x9E37_79B9)).collect();
|
||
let n = 3;
|
||
let mut shares = vec![0u64; n * v.len()];
|
||
split_into(&v, n, &mut stream(), &mut shares, 18).unwrap();
|
||
|
||
let mut out = vec![0u64; v.len()];
|
||
reconstruct_into(&shares, n, v.len(), &mut out).unwrap();
|
||
assert_eq!(out, v);
|
||
assert_ne!(&shares[..v.len()], &v[..], "单方分片不该等于原值");
|
||
}
|
||
|
||
/// 跨 CHUNK 边界的长度必须正确(500 > 64,覆盖多次分块)
|
||
#[test]
|
||
fn split_handles_multi_chunk() {
|
||
let v: Vec<u64> = (0..500).map(|i| (i * 7919) as u64).collect();
|
||
let n = 2;
|
||
let mut shares = vec![0u64; n * v.len()];
|
||
split_into(&v, n, &mut stream(), &mut shares, 18).unwrap();
|
||
let mut out = vec![0u64; v.len()];
|
||
reconstruct_into(&shares, n, v.len(), &mut out).unwrap();
|
||
assert_eq!(out, v);
|
||
}
|
||
|
||
#[test]
|
||
fn mul_triple_consistent() {
|
||
let n = 2;
|
||
let len = 32;
|
||
let mut d = Dealer::new([7u8; 32], n, 0);
|
||
let mut a = vec![0u64; n * len];
|
||
let mut b = vec![0u64; n * len];
|
||
let mut c = vec![0u64; n * len];
|
||
d.mul_triple(len, &mut a, &mut b, &mut c).unwrap();
|
||
|
||
let mut ra = vec![0u64; len];
|
||
let mut rb = vec![0u64; len];
|
||
let mut rc = vec![0u64; len];
|
||
reconstruct_into(&a, n, len, &mut ra).unwrap();
|
||
reconstruct_into(&b, n, len, &mut rb).unwrap();
|
||
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, "三元组不自洽");
|
||
}
|
||
|
||
#[test]
|
||
fn trunc_pair_consistent() {
|
||
let n = 2;
|
||
let len = 8;
|
||
let fxp = 18;
|
||
let mut d = Dealer::new([9u8; 32], n, fxp);
|
||
let mut r = vec![0u64; n * len];
|
||
let mut rt = vec![0u64; n * len];
|
||
d.trunc_pair(len, &mut r, &mut rt).unwrap();
|
||
|
||
let mut rr = vec![0u64; len];
|
||
let mut rrt = vec![0u64; len];
|
||
reconstruct_into(&r, n, len, &mut rr).unwrap();
|
||
reconstruct_into(&rt, n, len, &mut rrt).unwrap();
|
||
let mut want = vec![0u64; len];
|
||
ring::arshift_into(&rr, fxp, &mut want).unwrap();
|
||
assert_eq!(rrt, want, "截断对不自洽");
|
||
}
|
||
|
||
#[test]
|
||
fn edabit_bits_are_binary_and_share_r() {
|
||
let n = 2;
|
||
let len = 6;
|
||
let mut d = Dealer::new([3u8; 32], n, 0);
|
||
let stride = n * len;
|
||
let mut sh = vec![0u64; RING_BITS as usize * stride];
|
||
d.edabit(len, &mut sh).unwrap();
|
||
|
||
for i in 0..len {
|
||
for bit in 0..RING_BITS as usize {
|
||
let mut acc = 0u64;
|
||
for p in 0..n {
|
||
acc = acc.wrapping_add(sh[bit * stride + p * len + i]);
|
||
}
|
||
assert!(acc <= 1, "第 {bit} 位不是 0/1: {acc}");
|
||
}
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn edabit_multi_chunk() {
|
||
let n = 2;
|
||
let len = 100;
|
||
let mut d = Dealer::new([4u8; 32], n, 0);
|
||
let stride = n * len;
|
||
let mut sh = vec![0u64; RING_BITS as usize * stride];
|
||
d.edabit(len, &mut sh).unwrap();
|
||
assert_eq!(sh.len(), 64 * n * len);
|
||
}
|
||
|
||
#[test]
|
||
fn dealer_is_deterministic() {
|
||
let len = 16;
|
||
let n = 2;
|
||
let mut d1 = Dealer::new([5u8; 32], n, 18);
|
||
let mut d2 = Dealer::new([5u8; 32], n, 18);
|
||
let mut r1 = vec![0u64; n * len];
|
||
let mut t1 = vec![0u64; n * len];
|
||
let mut r2 = vec![0u64; n * len];
|
||
let mut t2 = vec![0u64; n * len];
|
||
d1.trunc_pair(len, &mut r1, &mut t1).unwrap();
|
||
d2.trunc_pair(len, &mut r2, &mut t2).unwrap();
|
||
assert_eq!(r1, r2, "同种子必须产出同物料");
|
||
assert_eq!(t1, t2);
|
||
}
|
||
}
|