Tari Crypto

这个crate是Tari Cryptocurrency项目的一部分。

该库的主要功能包括：

• Pedersen承诺
• Schnorr签名
• 通用公钥和私钥
• no-std支持

tari_crypto crate大量使用了优秀的Dalek库。Tari ECC的默认实现是Ristretto255曲线。

功能标志

bulletproofs_plus

添加对使用tari bulletproof plus库的范围证明的支持

serde

使用serde库为所有结构添加序列化和反序列化支持

borsh

使用borsh库为所有结构添加序列化和反序列化支持

precomputed_tables

使用优化的预计算表进行计算。虽然这比直接计算更快，但需要大量内存来存储，这对于小型no_std设备来说并不理想

WASM和FFI支持

TariCrypto提供了外部WASM和FFI包装器

基准测试

要运行基准测试：

$ cargo bench

基准测试使用Criterion并会生成漂亮的图表（如果安装了gnuplot）

完整示例代码

use tari_crypto::{
    keys::{PublicKey, SecretKey},
    ristretto::{RistrettoPublicKey, RistrettoSecretKey},
    signatures::SchnorrSignature,
};
use rand;

fn main() {
    // 生成密钥对
    let mut rng = rand::thread_rng();
    let k = RistrettoSecretKey::random(&mut rng);
    let p = RistrettoPublicKey::from_secret_key(&k);
    
    // 创建消息
    let message = "Tari crypto example".as_bytes();
    
    // 创建签名
    let signature = SchnorrSignature::sign(k.clone(), p.clone(), &message, &mut rng).unwrap();
    
    // 验证签名
    assert!(signature.verify(&p, &message));
    
    println!("Signature verified successfully!");
}

use tari_crypto::{
    commitment::HomomorphicCommitment,
    ristretto::{pedersen::PedersenCommitment, RistrettoSecretKey},
};
use rand;

fn main() {
    // 生成随机数和盲化因子
    let mut rng = rand::thread_rng();
    let value = RistrettoSecretKey::random(&mut rng);
    let blinding = RistrettoSecretKey::random(&mut rng);
    
    // 创建Pedersen承诺
    let commitment = PedersenCommitment::new(value.clone(), blinding.clone());
    
    // 验证承诺
    let expected = PedersenCommitment::new(value, blinding);
    assert_eq!(commitment, expected);
    
    println!("Commitment verified successfully!");
}

这些示例展示了如何使用tari_crypto库进行Schnorr签名和Pedersen承诺的基本操作。第一个示例演示了密钥生成、签名创建和验证过程，第二个示例展示了如何创建和验证Pedersen承诺。

更多完整示例

Schnorr签名高级用法示例

use tari_crypto::{
    keys::{PublicKey, SecretKey},
    ristretto::{RistrettoPublicKey, RistrettoSecretKey},
    signatures::SchnorrSignature,
};
use rand;

fn main() {
    // 初始化随机数生成器
    let mut rng = rand::thread_rng();
    
    // 生成多个密钥对
    let secret_keys: Vec<_> = (0..3).map(|_| RistrettoSecretKey::random(&mut rng)).collect();
    let public_keys: Vec<_> = secret_keys.iter()
        .map(|k| RistrettoPublicKey::from_secret_key(k))
        .collect();
    
    // 创建要签名的消息
    let message = "Multi-key Tari crypto example".as_bytes();
    
    // 为每个密钥对创建签名
    let signatures: Vec<_> = secret_keys.iter()
        .zip(public_keys.iter())
        .map(|(k, p)| SchnorrSignature::sign(k.clone(), p.clone(), &message, &mut rng).unwrap())
        .collect();
    
    // 批量验证所有签名
    let all_valid = signatures.iter()
        .zip(public_keys.iter())
        .all(|(sig, p)| sig.verify(p, &message));
    
    assert!(all_valid);
    println!("All {} signatures verified successfully!", signatures.len());
}

Pedersen承诺高级用法示例

use tari_crypto::{
    commitment::HomomorphicCommitment,
    ristretto::{pedersen::{PedersenCommitment, PedersenCommitmentFactory}, RistrettoSecretKey},
};
use rand;

fn main() {
    // 初始化随机数生成器
    let mut rng = rand::thread_rng();
    
    // 创建承诺工厂
    let factory = PedersenCommitmentFactory::default();
    
    // 生成多个值和盲化因子
    let values: Vec<_> = (0..5).map(|_| RistrettoSecretKey::random(&mut rng)).collect();
    let blinds: Vec<_> = (0..5).map(|_| RistrettoSecretKey::random(&mut rng)).collect();
    
    // 创建多个承诺
    let commitments: Vec<_> = values.iter()
        .zip(blinds.iter())
        .map(|(v, b)| factory.commit(v.clone(), b.clone()))
        .collect();
    
    // 验证承诺的正确性
    let all_valid = commitments.iter()
        .zip(values.iter())
        .zip(blinds.iter())
        .all(|((c, v), b)| *c == factory.commit(v.clone(), b.clone()));
    
    assert!(all_valid);
    println!("All {} commitments verified successfully!", commitments.len());
    
    // 演示同态加法
    let sum_commit = commitments.iter().fold(
        factory.commit(RistrettoSecretKey::default(), RistrettoSecretKey::default()),
        |acc, c| acc + c
    );
    let sum_value = values.iter().fold(
        RistrettoSecretKey::default(),
        |acc, v| acc + v
    );
    let sum_blind = blinds.iter().fold(
        RistrettoSecretKey::default(),
        |acc, b| acc + b
    );
    
    assert_eq!(sum_commit, factory.commit(sum_value, sum_blind));
    println!("Homomorphic addition verified successfully!");
}