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
BLAKE3 é uma função hash criptográfica que é:
- **Muito mais rápida** que MD5, SHA-1, SHA-2, SHA-3 e BLAKE2.
- **Segura**, ao contrário de MD5 e SHA-1. E segura contra extensão de comprimento, ao contrário de SHA-2.
- **Altamente paralelizável** em qualquer número de threads e lanes SIMD, porque é uma árvore de Merkle internamente.
- Capaz de **streaming verificado** e **atualizações incrementais**, novamente porque é uma árvore de Merkle.
- Uma **PRF**, **MAC**, **KDF** e **XOF**, além de um hash regular.
- **Um único algoritmo sem variantes**, que é rápido em x86-64 e também em arquiteturas menores.
O [gráfico abaixo](https://github.com/BLAKE3-team/BLAKE3-specs/blob/master/benchmarks/bar_chart.py) é 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](https://github.com/BLAKE3-team/BLAKE3-specs/blob/master/blake3.pdf).
<p align="center">
<img src="https://raw.githubusercontent.com/blake3-team/blake3/HEAD/media/speed.svg" alt="gráfico de desempenho">
</p>
BLAKE3 é baseada em uma instância otimizada da função hash estabelecida [BLAKE2](https://blake2.net) e no [modo de árvore Bao original](https://github.com/oconnor663/bao/blob/master/docs/spec_0.9.1.md). As especificações e a fundamentação do design estão disponíveis no [artigo do BLAKE3](https://github.com/BLAKE3-team/BLAKE3-specs/blob/master/blake3.pdf). O tamanho de saída padrão é 256 bits. A versão atual do [Bao](https://github.com/oconnor663/bao) implementa streaming verificado com BLAKE3.
Este repositório é a implementação oficial do BLAKE3. Inclui:
* A crate Rust [`blake3`](https://crates.io/crates/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`](https://crates.io/crates/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](https://github.com/blake3-team/blake3/blob/master/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`](https://github.com/blake3-team/blake3/blob/master/c/README.md).
* A [implementação de referência em Rust](https://github.com/blake3-team/blake3/blob/master/reference_impl/reference_impl.rs), discutida na Seção 5.1 do [artigo do BLAKE3](https://github.com/BLAKE3-team/BLAKE3-specs/blob/master/blake3.pdf). 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](https://github.com/oconnor663/blake3_reference_impl_c), [Python](https://github.com/oconnor663/pure_python_blake3)).
* Um [conjunto de vetores de teste](https://github.com/BLAKE3-team/BLAKE3/blob/master/test_vectors/test_vectors.json) que cobre saídas estendidas, todos os três modos e uma variedade de comprimentos de entrada.
* [](https://github.com/BLAKE3-team/BLAKE3/actions)
BLAKE3 foi projetado por:
* [@oconnor663] (Jack O'Connor)
* [@sneves] (Samuel Neves)
* [@veorq] (Jean-Philippe Aumasson)
* [@zookozcash] (Zooko)
O desenvolvimento do BLAKE3 foi patrocinado pela [Electric Coin Company](https://electriccoin.co).
O BLAKE3 também é [especificado](https://c2sp.org/BLAKE3) no [Community Cryptography Specification Project (C2SP)](https://c2sp.org).
*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](https://github.com/P-H-C/phc-winner-argon2).*
## Uso
### O utilitário `b3sum`
O 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](https://support.apple.com/guide/mac-help/open-a-mac-app-from-an-unidentified-developer-mh40616/mac)) na [página de releases](https://github.com/BLAKE3-team/BLAKE3/releases). Se você [instalou Rust e Cargo](https://doc.rust-lang.org/cargo/getting-started/installation.html), também pode compilar o `b3sum` você mesmo com:
```bash
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:
```bash
# 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
```
### A crate `blake3` [](https://docs.rs/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:
```rust
// 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:
```rust
// 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]"`:
```rust
// 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);
```
### A implementação em C
Veja [`c/README.md`](https://github.com/blake3-team/blake3/blob/master/c/README.md).
### Outras implementações
Existem muitas implementações por aí para acompanharmos, mas alguns destaques incluem [uma implementação otimizada em Go](https://github.com/zeebo/blake3), [ligações Wasm para Node.js e navegadores](https://github.com/connor4312/blake3), [wheels binários para Python](https://github.com/oconnor663/blake3-py), [ligações .NET](https://github.com/xoofx/Blake3.NET) e [uma implementação pura em Java](https://commons.apache.org/proper/commons-codec/apidocs/org/apache/commons/codec/digest/Blake3.html).
## Contribuindo
Por favor, veja [CONTRIBUTING.md](https://github.com/blake3-team/blake3/blob/master/CONTRIBUTING.md).
## Licenças
Este trabalho é dedicado ao domínio público com [CC0 1.0](https://github.com/blake3-team/blake3/blob/master/LICENSE_CC0). Alternativamente, é licenciado sob qualquer um dos seguintes:
* [Apache 2.0](https://github.com/blake3-team/blake3/blob/master/LICENSE_A2)
* [Apache 2.0 with LLVM exceptions](https://github.com/blake3-team/blake3/blob/master/LICENSE_A2LLVM)
## Adoção e implantação
* [Bazel](https://github.com/bazelbuild/bazel/releases/tag/6.4.0)
* [Cargo](https://github.com/rust-lang/cargo/pull/14137)
* [Ccache](https://ccache.dev/releasenotes.html#_ccache_4_0)
* [Chia](https://github.com/Chia-Network/chia-blockchain/blob/main/CHANGELOG.md#10beta8-aka-beta-18---2020-07-16)
* [Clickhouse](https://github.com/ClickHouse/ClickHouse/blob/master/rust/chcache/Cargo.toml#L7)
* [Farcaster](https://www.farcaster.xyz/)
* [IPFS](https://github.com/ipfs/go-verifcid/issues/13)
* [Iroh](https://www.iroh.computer/blog/blake3-hazmat-api)
* [LLVM](https://reviews.llvm.org/D121510)
* [Nix](https://github.com/NixOS/nix/pull/12379)
* [Nym](https://github.com/nymtech/nym/blob/59056a22c5e6b01a38da2124662bd1fa3c8abef2/common/nymsphinx/params/src/lib.rs#L5)
* [OpenZFS](https://github.com/openzfs/zfs/)
* [Redox](https://www.redox-os.org/news/pkgar-introduction/)
* [Solana](https://docs.rs/solana-program/1.9.5/solana_program/blake3/index.html)
* [Tekken 8](https://x.com/rodarmor/status/1751567502050771189)
* [Wasmer](https://github.com/wasmerio/wasmer/blob/4f935a8c162bf604df223003e434e4f7ca253688/lib/cache/src/hash.rs#L21)
## Miscelânea
- [@veorq] e [@oconnor663] fizeram [uma entrevista com a Cryptography FM](https://cryptography.fireside.fm/3).
- [@oconnor663] fez [uma entrevista com a Saito](https://www.youtube.com/watch?v=cJkmIt7yN_E).
[@oconnor663]: https://github.com/oconnor663
[@sneves]: https://github.com/sneves
[@veorq]: https://github.com/veorq
[@zookozcash]: https://github.com/zookozcash