AVX Hash - Documentação | AVX Crypto Security

Visão Geral

⚡ BLAKE3

Função de hash criptográfica moderna, extremamente rápida e segura. Baseada em BLAKE2 com melhorias significativas.

🔒 SHA-256

Padrão NIST amplamente utilizado. Implementação otimizada com aceleração de hardware quando disponível.

🚀 xxHash

Hash não-criptográfico extremamente rápido para checksums e tabelas hash. Ideal para performance crítica.

⚙️ Otimizações AVX

Aproveitamento de instruções SIMD (AVX2/AVX-512) para máxima performance em processadores modernos.

Tipos Disponíveis

Tipo	Descrição	Tamanho Saída
`Blake3`	Hash criptográfico BLAKE3	256 bits (variável)
`Sha256`	SHA-256 padrão NIST	256 bits
`Sha512`	SHA-512 para maior segurança	512 bits
`XxHash64`	xxHash 64 bits	64 bits
`XxHash128`	xxHash 128 bits	128 bits
`Hasher`	Trait genérico para hashers	Variável

Exemplos de Uso

Exemplo Básico - BLAKE3

use avx_hash::Blake3;

fn main() {
    // Criar hasher BLAKE3
    let mut hasher = Blake3::new();

    // Adicionar dados
    hasher.update(b"AVX Crypto Security");
    hasher.update(b" - Fast & Secure");

    // Finalizar e obter hash
    let hash = hasher.finalize();
    println!("BLAKE3: {}", hex::encode(hash));

    // Hash direto (one-shot)
    let hash = Blake3::hash(b"Mensagem completa");
    println!("Hash: {}", hex::encode(hash));
}

Exemplo - SHA-256

use avx_hash::Sha256;

fn main() {
    // SHA-256 hasher
    let mut hasher = Sha256::new();
    hasher.update(b"Dados importantes");

    let digest = hasher.finalize();
    println!("SHA-256: {}", hex::encode(digest));

    // Verificar integridade
    let expected = "abc123...";
    let computed = Sha256::hash(data);
    assert_eq!(hex::encode(computed), expected);

    println!("✅ Integridade verificada!");
}

Exemplo - xxHash (Performance)

use avx_hash::XxHash64;

fn main() {
    // xxHash para checksums rápidos
    let data = vec![0u8; 1_000_000]; // 1 MB

    let start = std::time::Instant::now();
    let hash = XxHash64::hash(&data);
    let duration = start.elapsed();

    println!("Hash: 0x{:016x}", hash);
    println!("Tempo: {:?}", duration);
    println!("Throughput: {:.2} GB/s",
        1.0 / duration.as_secs_f64());
}

Exemplo - Hash Streaming

use avx_hash::Blake3;
use std::fs::File;
use std::io::Read;

fn hash_file(path: &str) -> Result<[u8; 32], std::io::Error> {
    let mut file = File::open(path)?;
    let mut hasher = Blake3::new();
    let mut buffer = [0u8; 8192];

    loop {
        let n = file.read(&mut buffer)?;
        if n == 0 { break; }
        hasher.update(&buffer[..n]);
    }

    Ok(hasher.finalize())
}

Referências da API

Blake3

pub fn new() -> Self

Cria um novo hasher BLAKE3.

pub fn update(&mut self, data: &[u8])

Adiciona dados ao hash.

pub fn finalize(&self) -> [u8; 32]

Finaliza e retorna o hash.

pub fn hash(data: &[u8]) -> [u8; 32]

Calcula hash em uma única chamada.

Sha256

pub fn new() -> Self

Cria hasher SHA-256.

pub fn update(&mut self, data: &[u8])

Processa dados.

pub fn finalize(&self) -> [u8; 32]

Retorna digest SHA-256.

XxHash64

pub fn new(seed: u64) -> Self

Cria hasher com seed.

pub fn hash(data: &[u8]) -> u64

Calcula hash xxHash64.

Métricas de Performance

10 GB/s

BLAKE3

AVX2 otimizado

2.5 GB/s

SHA-256

Com SHA-NI

30 GB/s

xxHash

Não-criptográfico

< 50ns

Latência

Pequenos blocos

Throughput Comparativo (GB/s)

BLAKE3

SHA-256

SHA-512

xxHash64

Casos de Uso

🔐

Verificação de Integridade

Checksums de arquivos, verificação de downloads e detecção de alterações em dados.

🔑

Hash de Senhas

Base para KDFs (PBKDF2, Argon2) e armazenamento seguro de credenciais.

⛓️

Blockchain & Merkle Trees

Proof-of-work, árvores de Merkle e estruturas de dados criptográficas.

📊

Deduplicação de Dados

Identificação de conteúdo duplicado em sistemas de armazenamento e cache.

Licença

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