blake3-team/blake3Fonction de hachage cryptographique rapide avec modes PRF, MAC, KDF et XOF. Prend en charge le streaming vérifié, les mises à jour incrémentielles et le hachage parallélisé via une structure d'arbre de Merkle.
BLAKE3 est une fonction de hachage cryptographique qui est :
Le graphique ci-dessous est un exemple de benchmark avec des entrées de 16 Ko sur un processeur serveur Cascade Lake-SP 8275CL de 2019. Pour des benchmarks plus détaillés, consultez le papier BLAKE3.
BLAKE3 est basé sur une instance optimisée de la fonction de hachage établie BLAKE2 et sur le mode d'arbre Bao original. Les spécifications et la justification de la conception sont disponibles dans le papier BLAKE3. La taille de sortie par défaut est de 256 bits. La version actuelle de Bao implémente le streaming vérifié avec BLAKE3.
Ce dépôt est l'implémentation officielle de BLAKE3. Il inclut :
La crate Rust blake3, qui comprend des implémentations optimisées pour SSE2, SSE4.1, AVX2, AVX-512, NEON et WASM, avec détection automatique des fonctionnalités CPU au moment de l'exécution sur x86. La fonctionnalité rayon permet le multithreading.
La crate Rust b3sum, qui fournit une interface en ligne de commande. Elle utilise le multithreading par défaut, ce qui la rend un ordre de grandeur plus rapide que, par exemple, sha256sum sur du matériel de bureau typique.
L'implémentation C, qui, comme l'implémentation Rust, inclut des optimisations SIMD (toutes sauf WASM), la détection des fonctionnalités CPU sur x86 et un multithreading optionnel. Voir c/README.md.
L'implémentation de référence Rust, qui est discutée dans la section 5.1 du papier BLAKE3. Cette implémentation est beaucoup plus petite et plus simple que les optimisées ci-dessus. Si vous voulez voir comment BLAKE3 fonctionne, ou si vous écrivez un portage qui n'a pas besoin de multithreading ou d'optimisations SIMD, commencez ici. Les portages de l'implémentation de référence vers d'autres langages sont hébergés dans des dépôts séparés (C, Python).
Un ensemble de vecteurs de test qui couvre les sorties étendues, les trois modes et une variété de longueurs d'entrée.
BLAKE3 a été conçu par :
Le développement de BLAKE3 a été sponsorisé par Electric Coin Company.
BLAKE3 est également spécifié dans le Projet de Spécification de Cryptographie Communautaire (C2SP).
NOTE : BLAKE3 n'est pas un algorithme de hachage de mots de passe, car il est conçu pour être rapide, alors que le hachage de mots de passe ne devrait pas être rapide. Si vous hachez des mots de passe pour stocker les hachages ou si vous dérivez des clés à partir de mots de passe, nous recommandons Argon2.
b3sumL'utilitaire en ligne de commande b3sum affiche les hachages BLAKE3 des fichiers ou de l'entrée standard. Des binaires précompilés sont disponibles pour Linux, Windows et macOS (nécessitant la procédure de contournement pour développeur non identifié) sur la page des versions. Si vous avez installé Rust et Cargo, vous pouvez également compiler b3sum vous-même avec :
cargo install b3sum
Si rustup n'a pas configuré votre PATH pour vous, vous devrez peut-être chercher le binaire installé dans e.g. ~/.cargo/bin. Vous pouvez tester la rapidité de BLAKE3 sur votre machine en créant un gros fichier et en le hachant, par exemple :
# 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 
Pour utiliser BLAKE3 depuis du code Rust, ajoutez une dépendance à la crate blake3 dans votre Cargo.toml. Voici un exemple de hachage de quelques octets d'entrée :
// 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);
Outre hash, BLAKE3 propose deux autres modes, keyed_hash et derive_key. Le mode keyed_hash prend une clé 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);
Le mode derive_key prend une chaîne de contexte et du matériel de clé (pas un mot de passe). La chaîne de contexte doit être codée en dur, globalement unique et spécifique à l'application. Un bon format par défaut pour la chaîne de contexte est "[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);
Voir c/README.md.
Il y a trop d'implémentations pour que nous puissions les suivre, mais quelques points forts incluent une implémentation Go optimisée, des liaisons Wasm pour Node.js et les navigateurs, des wheels binaires pour Python, des liaisons .NET et une implémentation Java pure.
Veuillez consulter CONTRIBUTING.md.
Ce travail est mis dans le domaine public avec CC0 1.0. Alternativement, il est sous licence selon l'une des suivantes :
