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 ist eine kryptografische Hashfunktion, die:
Das folgende Diagramm 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.
BLAKE3 basiert auf einer optimierten Instanz der etablierten Hash-Funktion BLAKE2 und auf dem ursprünglichen Bao-Baum-Modus. Die Spezifikationen und das Design-Rationale sind im BLAKE3-Papier verfügbar. Die standardmäßige Ausgabegröße beträgt 256 Bits. Die aktuelle Version von Bao implementiert verifiziertes Streaming mit BLAKE3.
Dieses Repository ist die offizielle Implementierung von BLAKE3. Es enthält:
Die 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 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, 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.
Die Rust-Referenzimplementierung, die in Abschnitt 5.1 des BLAKE3-Papiers 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, Python).
Ein Satz von Testvektoren, der erweiterte Ausgaben, alle drei Modi und eine Vielzahl von Eingabelängen abdeckt.
BLAKE3 wurde entworfen von:
Die Entwicklung von BLAKE3 wurde von der Electric Coin Company gesponsert.
BLAKE3 ist auch spezifiziert im Community Cryptography Specification Project (C2SP).
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.
b3sumDas 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)
auf der Releases-Seite verfügbar.
Wenn Sie Rust und Cargo installiert haben, können Sie b3sum auch selbst mit folgendem Befehl erstellen:
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:
# 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-Crate 
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:
// 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:
// 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]":
// 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);
Siehe c/README.md.
Es gibt zu viele Implementierungen, als dass wir den Überblick behalten könnten, aber einige Highlights sind eine optimierte Go-Implementierung, Wasm-Bindungen für Node.js und Browser, binäre Wheels für Python, .NET-Bindungen und eine reine Java-Implementierung.
Bitte sehen Sie in die CONTRIBUTING.md.
Diese Arbeit ist der Gemeinfreiheit unter CC0 1.0 überlassen. Alternativ ist sie unter einer der folgenden Lizenzen lizenziert:
