blake3-team/blake3Funzione di hash crittografico veloce con modalità PRF, MAC, KDF e XOF. Supporta streaming verificato, aggiornamenti incrementali e hashing parallelizzato tramite struttura ad albero di Merkle.
BLAKE3 è una funzione hash crittografica che è:
Il grafico seguente è un esempio di benchmark con input di 16 KiB su una CPU server Cascade Lake-SP 8275CL del 2019. Per benchmark più dettagliati, consulta il paper su BLAKE3.
BLAKE3 si basa su un'istanza ottimizzata della consolidata funzione hash BLAKE2 e sulla modalità ad albero originale di Bao. Le specifiche e la logica di progettazione sono disponibili nel paper su BLAKE3. La dimensione di output predefinita è 256 bit. La versione corrente di Bao implementa lo streaming verificato con BLAKE3.
Questo repository è l'implementazione ufficiale di BLAKE3. Include:
La crate Rust blake3, che
include implementazioni ottimizzate per SSE2, SSE4.1, AVX2, AVX-512,
NEON e WASM, con rilevamento automatico delle funzionalità CPU in fase di esecuzione su x86.
La feature rayon fornisce multithreading.
La crate Rust b3sum, che
fornisce un'interfaccia a riga di comando. Usa il multithreading di default,
rendendolo un ordine di grandezza più veloce di ad esempio sha256sum su
hardware desktop tipico.
L'implementazione C, che come l'implementazione Rust include ottimizzazioni
SIMD (tutte tranne WASM), rilevamento delle funzionalità CPU su x86 e multithreading
opzionale. Vedi c/README.md.
L'implementazione di riferimento Rust, discussa nella Sezione 5.1 del paper su BLAKE3. Questa implementazione è molto più piccola e più semplice di quelle ottimizzate sopra. Se vuoi capire come funziona BLAKE3, o stai scrivendo un porting che non necessita di multithreading o ottimizzazioni SIMD, inizia qui. I porting dell'implementazione di riferimento in altri linguaggi sono ospitati in repository separati (C, Python).
Un insieme di vettori di test che copre output estesi, tutte e tre le modalità e una varietà di lunghezze di input.
BLAKE3 è stato progettato da:
Lo sviluppo di BLAKE3 è stato sponsorizzato da Electric Coin Company.
BLAKE3 è anche specificato nel Community Cryptography Specification Project (C2SP).
NOTA: BLAKE3 non è un algoritmo di hashing per password, perché è progettato per essere veloce, mentre l'hashing delle password non dovrebbe essere veloce. Se hashate le password per memorizzare gli hash o se derivate chiavi dalle password, raccomandiamo Argon2.
b3sumL'utility a riga di comando b3sum stampa gli hash BLAKE3 di file o dell'input
standard. I binari precompilati sono disponibili per Linux, Windows e
macOS (che richiede la soluzione per sviluppatore non
identificato)
nella pagina delle release.
Se hai installato Rust e
Cargo,
puoi anche compilare b3sum da te con:
cargo install b3sum
Se rustup non ha configurato il tuo PATH per te, potresti dover cercare
il binario installato in e.g. ~/.cargo/bin. Puoi testare
quanto è veloce BLAKE3 sulla tua macchina creando un file grande e
calcolandone l'hash, ad esempio:
# 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 
Per utilizzare BLAKE3 da codice Rust, aggiungi una dipendenza alla crate blake3 nel
tuo Cargo.toml. Ecco un esempio di hashing di alcuni byte di input:
// 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);
Oltre a hash, BLAKE3 fornisce altre due modalità, keyed_hash e
derive_key. La modalità keyed_hash prende una chiave a 256 bit:
// 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);
La modalità derive_key prende una stringa di contesto e del materiale chiave (non una
password). La stringa di contesto dovrebbe essere hardcodata, globalmente unica e
specifica per l'applicazione. Un buon formato predefinito per la stringa di contesto è
"[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);
Vedi c/README.md.
Ci sono troppe implementazioni là fuori per tenerne traccia, ma alcuni punti salienti includono un'implementazione Go ottimizzata, binding Wasm per Node.js e browser, wheel binari per Python, binding .NET e un'implementazione Java pura.
Si prega di vedere CONTRIBUTING.md.
Quest'opera è rilasciata nel pubblico dominio con CC0 1.0. In alternativa, è concessa in licenza sotto una delle seguenti:
