blake3-team/blake3Função hash criptográfica rápida com modos PRF, MAC, KDF e XOF. Suporta streaming verificado, atualizações incrementais e hashing paralelizado através da estrutura de árvore Merkle.
BLAKE3 é uma função hash criptográfica que é:
O gráfico abaixo é um exemplo de benchmark com entradas de 16 KiB em uma CPU de servidor Cascade Lake-SP 8275CL de 2019. Para benchmarks mais detalhados, veja o artigo do BLAKE3.
BLAKE3 é baseada em uma instância otimizada da função hash estabelecida BLAKE2 e no modo de árvore Bao original. As especificações e a fundamentação do design estão disponíveis no artigo do BLAKE3. O tamanho de saída padrão é 256 bits. A versão atual do Bao implementa streaming verificado com BLAKE3.
Este repositório é a implementação oficial do BLAKE3. Inclui:
A crate Rust blake3, que inclui implementações otimizadas para SSE2, SSE4.1, AVX2, AVX-512, NEON e WASM, com detecção automática de recursos de CPU em tempo de execução no x86. O recurso rayon oferece multithreading.
A crate Rust b3sum, que fornece uma interface de linha de comando. Ela usa multithreading por padrão, tornando-a uma ordem de grandeza mais rápida do que, por exemplo, sha256sum em hardware típico de desktop.
A implementação em C, que, assim como a implementação Rust, inclui otimizações SIMD (todas exceto WASM), detecção de recursos de CPU no x86 e multithreading opcional. Veja c/README.md.
A implementação de referência em Rust, discutida na Seção 5.1 do artigo do BLAKE3. Esta implementação é muito menor e mais simples do que as otimizadas acima. Se você quiser ver como o BLAKE3 funciona, ou estiver escrevendo uma porta que não precise de multithreading ou otimizações SIMD, comece aqui. Portas da implementação de referência para outras linguagens estão hospedadas em repositórios separados (C, Python).
Um conjunto de vetores de teste que cobre saídas estendidas, todos os três modos e uma variedade de comprimentos de entrada.
BLAKE3 foi projetado por:
O desenvolvimento do BLAKE3 foi patrocinado pela Electric Coin Company.
O BLAKE3 também é especificado no Community Cryptography Specification Project (C2SP).
NOTA: BLAKE3 não é um algoritmo de hash de senhas, pois foi projetado para ser rápido, enquanto o hash de senhas não deve ser rápido. Se você fizer hash de senhas para armazenar os hashes ou derivar chaves a partir de senhas, recomendamos o Argon2.
b3sumO utilitário de linha de comando b3sum imprime os hashes BLAKE3 de arquivos ou da entrada padrão. Binários pré-compilados estão disponíveis para Linux, Windows e macOS (exigindo o procedimento para desenvolvedor não identificado) na página de releases. Se você instalou Rust e Cargo, também pode compilar o b3sum você mesmo com:
cargo install b3sum
Se o rustup não configurou seu PATH para você, talvez seja necessário procurar o binário instalado em, por exemplo, ~/.cargo/bin. Você pode testar o quão rápido o BLAKE3 é na sua máquina criando um arquivo grande e calculando seu hash, por exemplo:
# Create a 1 GB file.
head -c 1000000000 /dev/zero > /tmp/bigfile
# Hash it with SHA-256.
time openssl sha256 /tmp/bigfile
# Hash it with BLAKE3.
time b3sum /tmp/bigfile
blake3 
Para usar o BLAKE3 a partir de código Rust, adicione uma dependência à crate blake3 no seu Cargo.toml. Aqui está um exemplo de hash de alguns bytes de entrada:
// Hash an input all at once.
let hash1 = blake3::hash(b"foobarbaz");
// Hash an input incrementally.
let mut hasher = blake3::Hasher::new();
hasher.update(b"foo");
hasher.update(b"bar");
hasher.update(b"baz");
let hash2 = hasher.finalize();
assert_eq!(hash1, hash2);
// Extended output. OutputReader also implements Read and Seek.
let mut output = [0; 1000];
let mut output_reader = hasher.finalize_xof();
output_reader.fill(&mut output);
assert_eq!(hash1, output[..32]);
// Print a hash as hex.
println!("{}", hash1);
Além de hash, o BLAKE3 fornece dois outros modos, keyed_hash e derive_key. O modo keyed_hash recebe uma chave de 256 bits:
// MAC an input all at once.
let example_key = [42u8; 32];
let mac1 = blake3::keyed_hash(&example_key, b"example input");
// MAC incrementally.
let mut hasher = blake3::Hasher::new_keyed(&example_key);
hasher.update(b"example input");
let mac2 = hasher.finalize();
assert_eq!(mac1, mac2);
O modo derive_key recebe uma string de contexto e algum material de chave (não uma senha). A string de contexto deve ser codificada, globalmente única e específica da aplicação. Um bom formato padrão para a string de contexto é "[application] [commit timestamp] [purpose]":
// Derive a couple of subkeys for different purposes.
const EMAIL_CONTEXT: &str = "BLAKE3 example 2020-01-07 17:10:44 email key";
const API_CONTEXT: &str = "BLAKE3 example 2020-01-07 17:11:21 API key";
let input_key_material = b"usually at least 32 random bytes, not a password";
let email_key = blake3::derive_key(EMAIL_CONTEXT, input_key_material);
let api_key = blake3::derive_key(API_CONTEXT, input_key_material);
assert_ne!(email_key, api_key);
Veja c/README.md.
Existem muitas implementações por aí para acompanharmos, mas alguns destaques incluem uma implementação otimizada em Go, ligações Wasm para Node.js e navegadores, wheels binários para Python, ligações .NET e uma implementação pura em Java.
Por favor, veja CONTRIBUTING.md.
Este trabalho é dedicado ao domínio público com CC0 1.0. Alternativamente, é licenciado sob qualquer um dos seguintes: