blake3-team/blake3Schnelle kryptografische Hashfunktion mit PRF-, MAC-, KDF- und XOF-Modi. Unterstützt verifiziertes Streaming, inkrementelle Aktualisierungen und parallelisiertes Hashing mittels Merkle-Baum-Struktur.
# BLAKE3
BLAKE3 ist eine kryptografische Hashfunktion, die:
- **Viel schneller** als MD5, SHA-1, SHA-2, SHA-3 und BLAKE2.
- **Sicher**, im Gegensatz zu MD5 und SHA-1. Und sicher gegen Längenerweiterung, anders als SHA-2.
- **Hochgradig parallelisierbar** über beliebig viele Threads und SIMD-Bahnen, da es sich im Inneren um einen Merkle-Baum handelt.
- Fähig zu **verifiziertem Streaming** und **inkrementellen Aktualisierungen**, wiederum aufgrund des Merkle-Baums.
- Ein **PRF**, **MAC**, **KDF** und **XOF** sowie ein regulärer Hash.
- **Ein Algorithmus ohne Varianten**, der auf x86-64 und auch auf kleineren Architekturen schnell ist.
Das [folgende Diagramm](https://github.com/BLAKE3-team/BLAKE3-specs/blob/master/benchmarks/bar_chart.py)
ist ein Beispiel-Benchmark für 16-KiB-Eingaben auf einem Cascade Lake-SP 8275CL Server-CPU
aus dem Jahr 2019. Ausführlichere Benchmarks finden Sie im
[BLAKE3-Papier](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="Leistungsgraph">
</p>
BLAKE3 basiert auf einer optimierten Instanz der etablierten Hash-Funktion
[BLAKE2](https://blake2.net) und auf dem [ursprünglichen Bao-Baum-Modus](https://github.com/oconnor663/bao/blob/master/docs/spec_0.9.1.md).
Die Spezifikationen und das Design-Rationale sind im [BLAKE3-Papier](https://github.com/BLAKE3-team/BLAKE3-specs/blob/master/blake3.pdf) verfügbar.
Die standardmäßige Ausgabegröße beträgt 256 Bits. Die aktuelle Version von
[Bao](https://github.com/oconnor663/bao) implementiert verifiziertes Streaming
mit BLAKE3.
Dieses Repository ist die offizielle Implementierung von BLAKE3. Es enthält:
* Die [`blake3`](https://crates.io/crates/blake3) Rust-Crate, die
optimierte Implementierungen für SSE2, SSE4.1, AVX2, AVX-512,
NEON und WASM enthält, mit automatischer CPU-Feature-Erkennung zur Laufzeit auf x86.
Das `rayon`-Feature bietet Multithreading.
* Die [`b3sum`](https://crates.io/crates/b3sum) Rust-Crate, die
eine Befehlszeilenschnittstelle bereitstellt. Standardmäßig wird Multithreading verwendet,
was es auf typischer Desktop-Hardware um Größenordnungen schneller macht als z. B. `sha256sum`.
* Die [C-Implementierung](https://github.com/blake3-team/blake3/blob/master/c), die wie die Rust-Implementierung SIMD-Optimierungen
(alle außer WASM), CPU-Feature-Erkennung auf x86 und optionales
Multithreading enthält. Siehe [`c/README.md`](https://github.com/blake3-team/blake3/blob/master/c/README.md).
* Die [Rust-Referenzimplementierung](https://github.com/blake3-team/blake3/blob/master/reference_impl/reference_impl.rs),
die in Abschnitt 5.1 des [BLAKE3-Papiers](https://github.com/BLAKE3-team/BLAKE3-specs/blob/master/blake3.pdf) besprochen wird.
Diese Implementierung ist viel kleiner und einfacher als die oben genannten
optimierten. Wenn Sie sehen möchten, wie BLAKE3 funktioniert, oder einen
Port schreiben, der kein Multithreading oder SIMD-Optimierungen benötigt,
beginnen Sie hier. Ports der Referenzimplementierung in andere Sprachen
werden in separaten Repositories gehostet
([C](https://github.com/oconnor663/blake3_reference_impl_c),
[Python](https://github.com/oconnor663/pure_python_blake3)).
* Ein [Satz von Testvektoren](https://github.com/BLAKE3-team/BLAKE3/blob/master/test_vectors/test_vectors.json),
der erweiterte Ausgaben, alle drei Modi und eine Vielzahl von Eingabelängen abdeckt.
* [](https://github.com/BLAKE3-team/BLAKE3/actions)
BLAKE3 wurde entworfen von:
* [@oconnor663] (Jack O'Connor)
* [@sneves] (Samuel Neves)
* [@veorq] (Jean-Philippe Aumasson)
* [@zookozcash] (Zooko)
Die Entwicklung von BLAKE3 wurde von der [Electric Coin Company](https://electriccoin.co) gesponsert.
BLAKE3 ist auch [spezifiziert](https://c2sp.org/BLAKE3) im [Community
Cryptography Specification Project (C2SP)](https://c2sp.org).
*HINWEIS: BLAKE3 ist kein Passwort-Hashing-Algorithmus, da es schnell sein soll, während Passwort-Hashing nicht schnell sein sollte. Wenn Sie Passwörter hashen, um die Hashes zu speichern, oder Schlüssel aus Passwörtern ableiten, empfehlen wir [Argon2](https://github.com/P-H-C/phc-winner-argon2).*
## Verwendung
### Das Dienstprogramm `b3sum`
Das Befehlszeilenprogramm `b3sum` gibt die BLAKE3-Hashes von Dateien oder der Standardeingabe aus.
Vorgefertigte Binärdateien sind für Linux, Windows und macOS (erfordert die [Problemumgehung für nicht identifizierte Entwickler](https://support.apple.com/guide/mac-help/open-a-mac-app-from-an-unidentified-developer-mh40616/mac))
auf der [Releases-Seite](https://github.com/BLAKE3-team/BLAKE3/releases) verfügbar.
Wenn Sie [Rust und Cargo installiert](https://doc.rust-lang.org/cargo/getting-started/installation.html) haben, können Sie `b3sum` auch selbst mit folgendem Befehl erstellen:
```bash
cargo install b3sum
```
Wenn `rustup` Ihre `PATH`-Variable nicht für Sie konfiguriert hat, müssen Sie möglicherweise nach der installierten Binärdatei suchen, z. B. in `~/.cargo/bin`. Sie können testen, wie schnell BLAKE3 auf Ihrem Rechner ist, indem Sie eine große Datei erstellen und hashen, zum Beispiel:
```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
```
### Die `blake3`-Crate [](https://docs.rs/blake3)
Um BLAKE3 aus Rust-Code zu verwenden, fügen Sie eine Abhängigkeit von der `blake3`-Crate zu Ihrer `Cargo.toml` hinzu. Hier ist ein Beispiel für das Hashen einiger Eingabebytes:
```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);
```
Neben `hash` bietet BLAKE3 zwei weitere Modi: `keyed_hash` und `derive_key`. Der Modus `keyed_hash` nimmt einen 256-Bit-Schlüssel:
```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);
```
Der Modus `derive_key` nimmt einen Kontext-String und ein Schlüsselmaterial (kein Passwort). Der Kontext-String sollte fest codiert, global eindeutig und anwendungsspezifisch sein. Ein gutes Standardformat für den Kontext-String ist `"[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);
```
### Die C-Implementierung
Siehe [`c/README.md`](https://github.com/blake3-team/blake3/blob/master/c/README.md).
### Andere Implementierungen
Es gibt zu viele Implementierungen, als dass wir den Überblick behalten könnten, aber einige Highlights sind [eine optimierte Go-Implementierung](https://github.com/zeebo/blake3), [Wasm-Bindungen für Node.js und Browser](https://github.com/connor4312/blake3), [binäre Wheels für Python](https://github.com/oconnor663/blake3-py), [.NET-Bindungen](https://github.com/xoofx/Blake3.NET) und [eine reine Java-Implementierung](https://commons.apache.org/proper/commons-codec/apidocs/org/apache/commons/codec/digest/Blake3.html).
## Mitwirken
Bitte sehen Sie in die [CONTRIBUTING.md](https://github.com/blake3-team/blake3/blob/master/CONTRIBUTING.md).
## Lizenzen
Diese Arbeit ist der Gemeinfreiheit unter [CC0 1.0](https://github.com/blake3-team/blake3/blob/master/LICENSE_CC0) überlassen.
Alternativ ist sie unter einer der folgenden Lizenzen lizenziert:
* [Apache 2.0](https://github.com/blake3-team/blake3/blob/master/LICENSE_A2)
* [Apache 2.0 mit LLVM-Ausnahmen](https://github.com/blake3-team/blake3/blob/master/LICENSE_A2LLVM)
## Adoption & Einsatz
* [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)
## Verschiedenes
- [@veorq] und [@oconnor663] haben [ein Interview mit Cryptography FM](https://cryptography.fireside.fm/3) geführt.
- [@oconnor663] hat [ein Interview mit Saito](https://www.youtube.com/watch?v=cJkmIt7yN_E) geführt.
[@oconnor663]: https://github.com/oconnor663
[@sneves]: https://github.com/sneves
[@veorq]: https://github.com/veorq
[@zookozcash]: https://github.com/zookozcash