AVX Threshold

Visão Geral

Tipos Disponíveis

Exemplos de Uso

Exemplo Básico - Threshold ECDSA

use avx_threshold::ThresholdEcdsa;

fn main() {
    // Configuração: 2-of-3 threshold
    let threshold = 2;
    let n_parties = 3;

    // DKG: gerar chave distribuída
    let parties = ThresholdEcdsa::distributed_keygen(
        threshold,
        n_parties
    ).expect("Erro no DKG");

    let key_shares = parties.iter()
        .map(|p| p.key_share())
        .collect::>();

    let public_key = parties[0].public_key();

    // Assinar com 2 partes (threshold = 2)
    let message = b"Transação importante";

    let sig1 = key_shares[0].sign_partial(message)
        .expect("Erro na assinatura parcial");
    let sig2 = key_shares[2].sign_partial(message)
        .expect("Erro na assinatura parcial");

    // Combinar assinaturas parciais
    let signature = ThresholdEcdsa::combine_signatures(&[sig1, sig2])
        .expect("Erro ao combinar");

    // Verificar (compatível com ECDSA padrão!)
    assert!(public_key.verify(message, &signature));
    println!("✅ Threshold ECDSA funcional!");
}

Exemplo - Distributed Key Generation

use avx_threshold::{DkgProtocol, Party};

fn main() {
    let threshold = 3;
    let n_parties = 5;

    // Cada participante inicia DKG
    let mut parties: Vec = (0..n_parties)
        .map(|id| Party::new(id, threshold, n_parties))
        .collect();

    // Fase 1: Broadcast de compromissos
    let commitments: Vec<_> = parties.iter()
        .map(|p| p.generate_commitments())
        .collect();

    // Fase 2: Troca de shares secretos
    for i in 0..n_parties {
        for j in 0..n_parties {
            if i != j {
                let share = parties[i].generate_share_for(j);
                parties[j].receive_share(i, share);
            }
        }
    }

    // Fase 3: Verificação
    for party in &mut parties {
        party.verify_shares(&commitments)
            .expect("Verificação falhou");
    }

    // Chave pública gerada (igual para todos)
    let public_key = parties[0].compute_public_key();
    println!("✅ DKG completo! PK: {}", hex::encode(public_key));
}

Exemplo - BLS Threshold

use avx_threshold::ThresholdBls;

fn main() {
    // BLS: agregação eficiente de assinaturas
    let threshold = 2;
    let n_parties = 4;

    let (key_shares, public_key) = ThresholdBls::keygen(
        threshold,
        n_parties
    ).expect("Erro no keygen");

    let message = b"Mensagem a assinar";

    // Cada parte assina
    let signatures: Vec<_> = key_shares.iter()
        .take(threshold) // Apenas threshold necessário
        .map(|share| share.sign(message))
        .collect();

    // Agregar assinaturas (muito eficiente!)
    let aggregated = ThresholdBls::aggregate(&signatures)
        .expect("Erro ao agregar");

    // Verificar assinatura agregada
    assert!(ThresholdBls::verify(&public_key, message, &aggregated));
    println!("✅ BLS threshold verificado!");
}

Exemplo - Key Refresh

use avx_threshold::{ThresholdEcdsa, KeyShare};

fn main() {
    // Key shares existentes
    let mut key_shares: Vec = load_existing_shares();
    let old_public_key = key_shares[0].public_key();

    // Refresh proativo (a cada X tempo)
    // Shares mudam, mas chave pública permanece igual
    ThresholdEcdsa::refresh_shares(&mut key_shares)
        .expect("Erro no refresh");

    let new_public_key = key_shares[0].public_key();

    // Chave pública inalterada
    assert_eq!(old_public_key, new_public_key);

    // Mas shares foram renovados (segurança proativa)
    println!("✅ Shares atualizados!");
    println!("Chave pública mantida: {}", hex::encode(new_public_key));
}

Referências da API

Métricas de Performance

Casos de Uso

Licença