AVX Post-Quantum - Documentação

Visão Geral

🔮 Kyber KEM

Key Encapsulation Mechanism pós-quântico. Vencedor do NIST PQC para criptografia de chave pública.

✍️ Dilithium

Assinaturas digitais resistentes a quantum. Vencedor do NIST PQC para assinaturas digitais.

🌳 SPHINCS+

Assinaturas stateless baseadas em hash. Segurança conservadora sem pressupostos matemáticos.

🛡️ Hybrid Crypto

Combinação de algoritmos clássicos e pós-quânticos. Segurança contra adversários atuais e futuros.

Tipos Disponíveis

Tipo	Descrição	Nível NIST
`Kyber512`	Kyber nível 1	NIST Level 1
`Kyber768`	Kyber nível 3 (recomendado)	NIST Level 3
`Kyber1024`	Kyber nível 5	NIST Level 5
`Dilithium2`	Dilithium nível 2	NIST Level 2
`Dilithium3`	Dilithium nível 3	NIST Level 3
`Dilithium5`	Dilithium nível 5	NIST Level 5
`SphincsPlusShake256`	SPHINCS+ com SHAKE256	Variável

Exemplos de Uso

Exemplo Básico - Kyber KEM

use avx_post_quantum::Kyber768;

fn main() {
    // Gerar par de chaves
    let (public_key, secret_key) = Kyber768::keypair()
        .expect("Erro ao gerar chaves");

    println!("Chave pública: {} bytes", public_key.len());

    // Encapsular (gera chave compartilhada)
    let (ciphertext, shared_secret_alice) =
        Kyber768::encapsulate(&public_key)
            .expect("Erro ao encapsular");

    // Desencapsular
    let shared_secret_bob = Kyber768::decapsulate(
        &ciphertext,
        &secret_key
    ).expect("Erro ao desencapsular");

    // Segredos devem ser iguais!
    assert_eq!(shared_secret_alice, shared_secret_bob);
    println!("✅ Kyber KEM funcional!");
    println!("Segredo compartilhado: {} bytes", shared_secret_alice.len());
}

Exemplo - Dilithium Signatures

use avx_post_quantum::Dilithium3;

fn main() {
    // Gerar par de chaves para assinaturas
    let (public_key, secret_key) = Dilithium3::keypair()
        .expect("Erro ao gerar chaves");

    // Assinar mensagem
    let message = b"Documento importante";
    let signature = Dilithium3::sign(message, &secret_key)
        .expect("Erro ao assinar");

    println!("Assinatura: {} bytes", signature.len());

    // Verificar assinatura
    let is_valid = Dilithium3::verify(
        message,
        &signature,
        &public_key
    );

    assert!(is_valid);
    println!("✅ Dilithium assinatura verificada!");
}

Exemplo - SPHINCS+

use avx_post_quantum::SphincsPlusShake256;

fn main() {
    // SPHINCS+: stateless, baseado em hash
    let (public_key, secret_key) =
        SphincsPlusShake256::keypair_128f() // Fast variant
            .expect("Erro ao gerar chaves");

    let message = b"Mensagem para assinar";

    // Assinar (stateless, sem estado)
    let signature = SphincsPlusShake256::sign(
        message,
        &secret_key
    ).expect("Erro ao assinar");

    // Verificar
    let is_valid = SphincsPlusShake256::verify(
        message,
        &signature,
        &public_key
    );

    assert!(is_valid);
    println!("✅ SPHINCS+ verificado!");
    println!("Segurança conservadora: baseado em hash");
}

Exemplo - Hybrid Cryptography

use avx_post_quantum::{Kyber768, HybridKem};
use avx_crypto::curves::X25519;

fn main() {
    // Combinar X25519 (clássico) + Kyber768 (PQC)
    let hybrid = HybridKem::new();

    // Gerar chaves híbridas
    let (pk_classical, sk_classical) = X25519::keypair();
    let (pk_pqc, sk_pqc) = Kyber768::keypair().unwrap();

    // Encapsulação híbrida
    let (ct_classical, ct_pqc, shared_secret) =
        hybrid.encapsulate(&pk_classical, &pk_pqc)
            .expect("Erro ao encapsular");

    // Desencapsulação híbrida
    let recovered = hybrid.decapsulate(
        &ct_classical,
        &ct_pqc,
        &sk_classical,
        &sk_pqc
    ).expect("Erro ao desencapsular");

    assert_eq!(shared_secret, recovered);
    println!("✅ Criptografia híbrida!");
    println!("Seguro contra ameaças clássicas E quânticas");
}

Referências da API

Kyber768

pub fn keypair() -> Result<(PublicKey, SecretKey), PqError>

Gera par de chaves Kyber-768.

pub fn encapsulate(pk: &PublicKey) -> Result<(Ciphertext, SharedSecret), PqError>

Encapsula gerando segredo compartilhado.

pub fn decapsulate(ct: &Ciphertext, sk: &SecretKey) -> Result<SharedSecret, PqError>

Desencapsula recuperando segredo.

Dilithium3

pub fn keypair() -> Result<(PublicKey, SecretKey), PqError>

Gera par de chaves Dilithium-3.

pub fn sign(message: &[u8], sk: &SecretKey) -> Result<Signature, PqError>

Assina mensagem.

pub fn verify(message: &[u8], sig: &Signature, pk: &PublicKey) -> bool

Verifica assinatura Dilithium.

Métricas de Performance

~0.5ms

Kyber Encap/Decap

Muito rápido

~2ms

Dilithium Sign

Nível 3

~1ms

Dilithium Verify

Verificação rápida

~50ms

SPHINCS+ Sign

Trade-off segurança

Casos de Uso

🔐

TLS Pós-Quântico

Proteção de comunicações contra "harvest now, decrypt later". Kyber para key exchange.

📜

PKI do Futuro

Certificados digitais resistentes a quantum. Dilithium para assinaturas de longa duração.

💰

Blockchain Quântico-Seguro

Proteger criptomoedas e ativos digitais de futuras ameaças quânticas.

🏛️

Segurança Governamental

Proteção de informações classificadas com prazo de sigilo de décadas.

Licença

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