AVX MPC - Documentação | AVX Crypto Security

Visão Geral

🤝 Computação Colaborativa

Múltiplas partes computam funções sobre dados privados sem revelar suas entradas. Mantém privacidade total.

🔐 Secret Sharing

Esquemas Shamir e Feldman para dividir segredos entre participantes. Recuperação com threshold configurável.

🛡️ Privacy Preserving

Computação sem revelar dados sensíveis. Ideal para colaboração entre organizações com dados confidenciais.

⚡ Protocolos Otimizados

Implementações eficientes de protocolos MPC modernos com mínima overhead de comunicação.

Tipos Disponíveis

Tipo	Descrição	Modelo de Segurança
`ShamirSecretSharing`	Compartilhamento de segredo Shamir	Information-theoretic
`FeldmanVSS`	Verifiable Secret Sharing	Computational
`MpcProtocol`	Protocolo MPC genérico	Semi-honest / Malicious
`SecretShare`	Compartilhamento individual	Threshold-based
`MpcParty`	Participante do protocolo	Authenticated
`ThresholdScheme`	Esquema de threshold	(t, n)-threshold

Exemplos de Uso

Exemplo Básico - Shamir Secret Sharing

use avx_mpc::ShamirSecretSharing;

fn main() {
    // Configuração: (3, 5) threshold
    // Necessário 3 de 5 shares para recuperar
    let threshold = 3;
    let total_shares = 5;

    let secret = b"Segredo muito importante!";

    // Dividir segredo
    let sss = ShamirSecretSharing::new(threshold, total_shares);
    let shares = sss.split(secret)
        .expect("Falha ao dividir segredo");

    println!("✅ Segredo dividido em {} shares", shares.len());

    // Recuperar com 3 shares quaisquer
    let recovered = sss.reconstruct(&shares[0..3])
        .expect("Falha ao recuperar");

    assert_eq!(secret, recovered.as_slice());
    println!("✅ Segredo recuperado!");
}

Exemplo - Feldman VSS (Verifiable)

use avx_mpc::FeldmanVSS;

fn main() {
    let threshold = 2;
    let n_parties = 4;

    let secret = b"Chave mestra";

    // Criar VSS verificável
    let vss = FeldmanVSS::new(threshold, n_parties);
    let (shares, commitments) = vss.share_secret(secret)
        .expect("Erro ao compartilhar");

    // Cada participante verifica seu share
    for (i, share) in shares.iter().enumerate() {
        let is_valid = vss.verify_share(share, &commitments);
        assert!(is_valid);
        println!("✅ Share {} verificado", i);
    }

    // Recuperar secreto
    let recovered = vss.reconstruct(&shares[0..threshold])
        .expect("Erro na recuperação");

    assert_eq!(secret, recovered.as_slice());
}

Exemplo - Computação MPC

use avx_mpc::{MpcProtocol, MpcParty};

fn main() {
    // Criar 3 participantes
    let party1 = MpcParty::new(1, vec![2, 3]);
    let party2 = MpcParty::new(2, vec![1, 3]);
    let party3 = MpcParty::new(3, vec![1, 2]);

    // Cada um tem entrada privada
    let input1 = 100u64;
    let input2 = 200u64;
    let input3 = 50u64;

    // Computar soma sem revelar entradas individuais
    let protocol = MpcProtocol::new(vec![party1, party2, party3]);

    let result = protocol.compute_sum(&[
        input1, input2, input3
    ]).expect("Erro no MPC");

    println!("Soma MPC: {}", result); // 350
    // Nenhum participante conhece as entradas dos outros!
}

Exemplo - Assinatura Distribuída

use avx_mpc::{DistributedSignature, ThresholdScheme};

fn main() {
    // Chave privada dividida entre 5 partes
    // Necessário 3 para assinar
    let scheme = ThresholdScheme::new(3, 5);
    let private_key = generate_key();

    let key_shares = scheme.split_key(&private_key)
        .expect("Erro ao dividir chave");

    // 3 partes colaboram para assinar
    let message = b"Transação importante";
    let sig_shares = vec![
        key_shares[0].sign(message),
        key_shares[2].sign(message),
        key_shares[4].sign(message),
    ];

    // Combinar assinaturas parciais
    let signature = scheme.combine_signatures(&sig_shares)
        .expect("Erro ao combinar");

    // Verificar assinatura final
    assert!(verify_signature(&public_key, message, &signature));
    println!("✅ Assinatura distribuída criada!");
}

Referências da API

ShamirSecretSharing

pub fn new(threshold: usize, total: usize) -> Self

Cria esquema (t, n)-threshold.

pub fn split(&self, secret: &[u8]) -> Result<Vec<SecretShare>, MpcError>

Divide segredo em shares.

pub fn reconstruct(&self, shares: &[SecretShare]) -> Result<Vec<u8>, MpcError>

Recupera segredo de shares.

FeldmanVSS

pub fn new(threshold: usize, n_parties: usize) -> Self

Cria VSS verificável.

pub fn share_secret(&self, secret: &[u8]) -> Result<(Vec<Share>, Vec<Commitment>), MpcError>

Compartilha com compromissos.

pub fn verify_share(&self, share: &Share, commitments: &[Commitment]) -> bool

Verifica validade do share.

MpcProtocol

pub fn new(parties: Vec<MpcParty>) -> Self

Inicializa protocolo MPC.

pub fn compute_sum(&self, inputs: &[u64]) -> Result<u64, MpcError>

Computa soma preservando privacidade.

Métricas de Performance

< 10ms

Secret Sharing

5 shares

< 5ms

Reconstruction

Threshold 3/5

~100ms

Computação MPC

3 parties

< 1ms

Verificação VSS

Por share

Casos de Uso

🔑

Gerenciamento de Chaves

Dividir chaves privadas entre múltiplos participantes. Nenhuma parte única tem controle total.

✍️

Assinaturas Threshold

Assinaturas digitais que requerem colaboração de múltiplas partes para serem geradas.

💰

Carteiras Multi-Sig

Carteiras criptográficas que exigem múltiplas aprovações para realizar transações.

🏦

Análise Privada de Dados

Computação conjunta sobre dados sensíveis de múltiplas organizações sem revelar dados brutos.

Licença

Para licenciamento comercial, entre em contato: nicolas@avila.inc