Lib.rs

vrf-mod

vrf-mod是Verifiable Random Functions (VRFs) 和椭圆曲线VRFs的开源实现，用Rust编写。此库遵循VRF-draft-05中描述的算法。

• VRF-draft-05
• RFC6979

免责声明：实验性

VRF

此模块使用OpenSSL库进行大数密码学运算。

支持的加密套件包括

• PKI_MGF_MGF1_SHA1：使用SHA1的掩码生成算法。
• PKI_MGF_MGF1_SHA256：使用SHA256的掩码生成算法。

use vrf_mod::vrf::{VRFCipherSuite, VRF};
use vrf_mod::VRF as VRF_trait;
use openssl::rsa::Rsa;

fn main() {
    // Initialization of VRF context
    let mut vrf = VRF::from_suite(VRFCipherSuite::PKI_MGF_MGF1_SHA256).unwrap();
    // Load private key from a file
    let pkey = include_bytes!("../link_to_file/rsa.pem");
    let private_key = Rsa::private_key_from_pem(pkey).unwrap();
    // Load public key from a file
    let key = include_bytes!("../link_to_file/rsa.pem.pub");
    let public_key = Rsa::public_key_from_pem(key).unwrap();
    // Inputs: Secret Key, Public Key (derived) & Message
    let message: &[u8] = b"sample";
    
    // VRF proof and hash output
    let pi = vrf.prove(&private_key, &message).unwrap();
    let hash = vrf.proof_to_hash(&pi).unwrap();

    // VRF proof verification (returns VRF hash output)
    let beta = vrf.verify(&public_key, &message, &pi);
}

添加不受支持的加密套件

此库还定义了一个可扩展的VRF trait。

use openssl::{
    rsa::Rsa,
    pkey::{Public, Private}.
};

pub trait VRF {
    type Error;

    fn prove(&mut self, pkey: &Rsa<Private>, alpha_string: &[u8]) -> Result<Vec<u8>, Self::Error>;

    fn proof_to_hash(&mut self, pi_string: &[u8]) -> Result<Vec<u8>, Self::Error>;

    fn verify(&mut self, public_key: &Rsa<Public>, alpha_string: &[u8], pi_string: &[u8]) -> Result<Vec<u8>, Self::Error>;
}

椭圆曲线VRF

此模块还使用OpenSSL库提供椭圆曲线可验证随机函数 (VRF) 功能。

支持的加密套件包括

• P256_SHA256_TAI：使用SHA256和secp256r1曲线（即NIST P-256）的算法。
• SECP256K1_SHA256_TAI：使用SHA256和secp256k1曲线的算法。

use vrf_mod::ecvrf::{CipherSuite, ECVRF};
use vrf_mod::ECVRF as ECVRF_trait;

fn main() {
    // Initialization of VRF context by providing a curve
    let mut ecvrf = ECVRF::from_suite(CipherSuite::P256_SHA256_TAI).unwrap();
    // Private Key, Public Key (derived) & message
    let private_key = hex::decode("c9afa9d845ba75166b5c215767b1d6934e50c3db36e89b127b8a622b120f6721").unwrap();
    let public_key = ecvrf.derive_public_key(&private_key).unwrap();
    let message: &[u8] = b"sample";
    
    // ECVRF proof and hash output
    let pi = ecvrf.prove(&private_key, &message).unwrap();
    let hash = ecvrf.proof_to_hash(&pi).unwrap();

    // ECVRF proof verification (returns ECVRF hash output)
    let beta = ecvrf.verify(&public_key, &message, &pi);
}

pub trait ECVRF<PrivateKey, PublicKey> {
    type Error;

    fn prove(&mut self, pkey: PrivateKey, alpha_string: &[u8]) -> Result<Vec<u8>, Self::Error>;

    fn proof_to_hash(&mut self, pi_string: &[u8]) -> Result<Vec<u8>, Self::Error>;

    fn verify(&mut self, public_key: PublicKey, alpha_string: &[u8], pi_string: &[u8]) -> Result<Vec<u8>, Self::Error>;
}