Rust秘密共享库vsss-rs的使用：实现安全高效的阈值秘密共享方案

可验证的秘密共享方案

这个crate提供了各种密码学可验证的秘密共享方案，当Rust标准库可用时。

• 此实现目前正在审核中，审核完成后将发布结果。在此之前请自行承担使用风险。
• 此实现不需要Rust标准库。
• 除非明确注明，否则所有操作都是常数时间。

从版本2升级的注意事项

接口已重新设计以相互兼容并支持序列化。

从版本3升级的注意事项

ShareIdentifier trait已修改如下：

• to_buffer 接收一个字节缓冲区并用标识符的字节表示填充内容
• from_buffer 接收一个字节缓冲区并从字节表示创建标识符
• to_vec 如果启用了features=alloc或std，则返回字节表示作为Vec

文档

可验证的秘密共享方案用于将秘密分成多个份额并在不同实体之间分发，能够验证份额是否正确并属于特定集合。这个crate包括Shamir的秘密共享方案，它不支持验证，但更多是其他方案的基础构建块。

这个crate支持Feldman和Pedersen可验证的秘密共享方案。

默认方法

分割和组合秘密的默认方法是：

• shamir::split_secret
• feldman::split_secret
• pedersen::split_secret
• combine_shares
• combine_shares_group

完整示例代码

P-256示例

use vsss_rs::{*, shamir};
use elliptic_curve::ff::PrimeField;
use p256::{NonZeroScalar, Scalar, SecretKey};

let mut osrng = rand_core::OsRng::default();
let sk = SecretKey::random(&mut osrng);
let nzs = sk.to_nonzero_scalar();
let res = shamir::split_secret::<Scalar, u8, Vec<u8>>(2, 3, *nzs.as_ref(), &mut osrng);
assert!(res.is_ok());
let shares = res.unwrap();
let res = combine_shares(&shares);
assert!(res.is_ok());
let scalar: Scalar = res.unwrap();
let nzs_dup = NonZeroScalar::from_repr(scalar.to_repr()).unwrap();
let sk_dup = SecretKey::from(nzs_dup);
assert_eq!(sk_dup.to_bytes(), sk.to_bytes());

或者使用DefaultStdVsss结构体：

use elliptic_curve::ff::Field;

let mut osrng = rand_core::OsRng::default();
let secret = p256::Scalar::random(&mut osrng);
let res = DefaultStdVsss::<p256::ProjectivePoint>::split_secret(2, 3, secret, &mut osrng);
assert!(res.is_ok());
let shares = res.unwrap();
let res = combine_shares(&shares);
assert!(res.is_ok());
let scalar: p256::Scalar = res.unwrap();
assert_eq!(secret, scalar);

Secp256k1示例

use vsss_rs::{*, shamir};
use elliptic_curve::ff::PrimeField;
use k256::{NonZeroScalar, Scalar, ProjectivePoint, SecretKey};

let mut osrng = rand_core::OsRng::default();
let sk = SecretKey::random(&mut osrng);
let secret = *sk.to_nonzero_scalar();
let res = shamir::split_secret::<Scalar, [u8; 1], u8, Vec<u8>>(2, 3, secret, &mut osrng);
assert!(res.is_ok());
let shares = res.unwrap();
let res = combine_shares(&shares);
assert!(res.is_ok());
let scalar: Scalar = res.unwrap();
let nzs_dup = NonZeroScalar::from_repr(scalar.to_repr()).unwrap();
let sk_dup = SecretKey::from(nzs_dup);
assert_eq!( sk_dup.to_bytes(), sk.to_bytes());

Curve25519示例

use curve25519_dalek::scalar::Scalar;
use rand::Rng;
use ed25519_dalek::SecretKey;
use vsss_rs::{curve25519::WrappedScalar, *};
use x25519_dalek::StaticSecret;

let mut osrng = rand::rngs::OsRng::default();
let sc = Scalar::hash_from_bytes::<sha2::Sha512>(&osrng.gen::<[u8; 32]>());
let sk1 = StaticSecret::from(sc.to_bytes());
let ske1 = SecretKey::from_bytes(&sc.to_bytes()).unwrap();
let res = shamir::split_secret::<WrappedScalar, [u8; 1], u8, Vec<u8>>(2, 3, sc.into(), &mut osrng);
assert!(res.is_ok());
let shares = res.unwrap();
let res = combine_shares(&shares);
assert!(res.is_ok());
let scalar: WrappedScalar = res.unwrap();
assert_eq!(scalar.0, sc);
let sk2 = StaticSecret::from(scalar.0.to_bytes());
let ske2 = SecretKey::from_bytes(&scalar.0.to_bytes()).unwrap();
assert_eq!(sk2.to_bytes(), sk1.to_bytes());
assert_eq!(ske1.to_bytes(), ske2.to_bytes());

完整示例demo

以下是一个完整的示例，展示如何使用vsss-rs实现阈值秘密共享：

// 导入必要的库
use vsss_rs::{*, shamir};
use p256::{NonZeroScalar, Scalar, SecretKey};
use rand_core::OsRng;

fn main() {
    // 初始化随机数生成器
    let mut rng = OsRng::default();
    
    // 1. 创建一个秘密密钥
    let secret_key = SecretKey::random(&mut rng);
    let secret_scalar = *secret_key.to_nonzero_scalar();
    
    // 2. 使用Shamir方案分割秘密(2-3阈值方案)
    let shares_result = shamir::split_secret::<Scalar, u8, Vec<u8>>(
        2,  // 阈值
        3,  // 总份额数
        secret_scalar, 
        &mut rng
    );
    
    // 处理结果
    let shares = match shares_result {
        Ok(s) => s,
        Err(e) => {
            println!("分割秘密失败: {:?}", e);
            return;
        }
    };
    
    // 3. 验证我们可以用足够的份额恢复秘密
    let recovery_result = combine_shares(&shares[0..2]); // 使用2个份额
    
    match recovery_result {
        Ok(recovered) => {
            let recovered_scalar: Scalar = recovered;
            let recovered_key = SecretKey::from(
                NonZeroScalar::from_repr(recovered_scalar.to_repr()).unwrap()
            );
            
            // 验证恢复的密钥与原始密钥相同
            assert_eq!(recovered_key.to_bytes(), secret_key.to_bytes());
            println!("成功恢复秘密密钥!");
        }
        Err(e) => println!("恢复秘密失败: {:?}", e),
    }
}

许可证

根据以下任一许可授权：

• Apache License, Version 2.0
• MIT license

贡献

除非您明确声明，否则根据Apache-2.0许可证提交的任何贡献都应按照上述许可授权，不附加任何其他条款或条件。