Files
ssw-mpc/crates/mpc-core/src/share.rs
T
admin 54781b3f83
ci / gate (push) Waiting to run
refactor: 项目改名 ssw-mpc,crate 统一到 mpc-* 前缀
- 项目与文档标题:nax-rs → ssw-mpc(尚数网-多方安全计算),二进制 nax → mpc
- 18 个 crate 及目录 nax-* → mpc-*,Rust 引用 nax_* → mpc_*
- 环境变量、C 符号、构建/部署脚本:NAX_* → MPC_*、libnax_ray.so → libmpc_ray.so
- 保留协议域分隔常量与 refs/nax 参考实现路径,维持 golden 向量与历史数据兼容
- 新增 [profile.dev] incremental=false
2026-11-05 15:06:12 +08:00

487 lines
15 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! 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);
}
}