BLS Threshold Crypto

BLS Threshold Crypto (blsttc) is a Rust implementation of BLS (Boneh-Lynn-Shacham) threshold signatures with support for both Rust and Python interfaces.

Installation

Rust

# Add to Cargo.toml
[dependencies]
blsttc = "8.0.2"

Python

Basic Usage

Rust

use blsttc::{SecretKey, PublicKey, Signature};

// Generate a secret key
let secret_key = SecretKey::random();

// Get the corresponding public key
let public_key = secret_key.public_key();

// Sign a message
let message = b"Hello, World!";
let signature = secret_key.sign(message);

// Verify the signature
assert!(public_key.verify(&signature, message));

Python

Threshold Signatures

Rust

use blsttc::{SecretKeySet, PublicKeySet};

// Create a threshold signature scheme
let threshold = 3;  // Minimum signatures required
let total = 5;      // Total number of shares
let sk_set = SecretKeySet::random(threshold);

// Get the public key set
let pk_set = sk_set.public_keys();

// Generate secret key shares
let secret_shares: Vec<_> = (0..total)
    .map(|i| sk_set.secret_key_share(i))
    .collect();

// Sign with individual shares
let message = b"Hello, World!";
let sig_shares: Vec<_> = secret_shares
    .iter()
    .map(|share| share.sign(message))
    .collect();

// Combine signatures
let combined_sig = pk_set.combine_signatures(sig_shares[..threshold].iter())?;

// Verify the combined signature
assert!(pk_set.public_key().verify(&combined_sig, message));

Python

Advanced Features

Key Generation

Rust

use blsttc::{SecretKey, Fr};
use rand::thread_rng;

// Generate from random seed
let secret_key = SecretKey::random();

// Generate from bytes
let bytes_data = b"some-32-byte-seed";
let secret_key = SecretKey::from_bytes(bytes_data)?;

// Generate from field element
let fr = Fr::random();
let secret_key = SecretKey::from_fr(&fr);

Python

Serialization

Rust

// Serialize keys and signatures
let sk_bytes = secret_key.to_bytes();
let pk_bytes = public_key.to_bytes();
let sig_bytes = signature.to_bytes();

// Deserialize
let sk = SecretKey::from_bytes(&sk_bytes)?;
let pk = PublicKey::from_bytes(&pk_bytes)?;
let sig = Signature::from_bytes(&sig_bytes)?;

Python

Error Handling

Rust

use blsttc::error::Error;

// Handle key generation errors
match SecretKey::from_bytes(invalid_bytes) {
    Ok(sk) => println!("Key generated successfully"),
    Err(Error::InvalidBytes) => println!("Invalid key bytes"),
    Err(e) => println!("Other error: {}", e),
}

// Handle signature verification
if !pk.verify(&sig, msg) {
    println!("Invalid signature");
}

Python

Best Practices

1. Key Management

   • Securely store private keys

   • Use strong random number generation

   • Implement key rotation policies

2. Threshold Selection

   • Choose appropriate threshold values

   • Consider fault tolerance requirements

   • Balance security and availability

3. Performance

   • Cache public keys when possible

   • Batch verify signatures when possible

   • Use appropriate buffer sizes

4. Security

   • Validate all inputs

   • Use secure random number generation

   • Implement proper error handling

Common Use Cases

1. Distributed Key Generation

   • Generate keys for distributed systems

   • Share keys among multiple parties

   • Implement threshold cryptography

2. Signature Aggregation

   • Combine multiple signatures

   • Reduce signature size

   • Improve verification efficiency

3. Consensus Protocols

   • Implement Byzantine fault tolerance

   • Create distributed voting systems

   • Build secure multiparty computation