The release of the reference implementation of the cryptographic hash function BLAKE3 1.0 has occurred, notable for its very high hash computation performance while ensuring reliability at the level of SHA-3. In tests generating a hash for a 16 KB file, BLAKE3 with a 256-bit key outperforms SHA3-256 by 17 times, SHA-256 by 14 times, SHA-512 by 9 times, SHA-1 by 6 times, and BLAKE2b by 5 times. A significant lead is maintained even when processing very large volumes of data; for instance, BLAKE3 is 8 times faster than SHA-256 when computing a hash for 1 GB of random data. The reference implementation code for BLAKE3 is available in C and Rust under a dual license — public domain (CC0) and Apache 2.0.
The hash function is intended for applications such as file integrity verification, message authentication, and generating data for cryptographic digital signatures. BLAKE3 is not designed for password hashing, as it is aimed at maximum hash computation speed (for passwords, it is recommended to use slower hash functions like yescrypt, bcrypt, scrypt, or Argon2). This hash function is insensitive to the size of the data being hashed and is protected against collision attacks and preimage attacks.
The algorithm was developed by well-known cryptography experts (Jack O’Connor, Jean-Philippe Aumasson, Samuel Neves, Zooko Wilcox-O’Hearn) and continues the development of the BLAKE2 algorithm, utilizing the Bao mechanism for encoding block chain trees. Unlike BLAKE2 (BLAKE2b, BLAKE2s), BLAKE3 offers a single algorithm for all platforms, independent of bitness and hash size.
Performance improvements were achieved by reducing the number of rounds from 10 to 7 and separating the hashing of blocks into chunks of 1 KB. According to the creators, they found compelling mathematical proof that 7 rounds can suffice instead of 10 while maintaining the same level of reliability (for illustration, consider mixing fruits in a blender—after 7 seconds, the fruits are already fully blended, and the additional 3 seconds won't affect the consistency of the mixture). However, some researchers express doubt, believing that even if 7 rounds are currently sufficient to withstand all known attacks on hashes, the additional 3 rounds might prove beneficial should new attacks emerge in the future.
Regarding the chunking, in BLAKE3 the stream is divided into 1 KB pieces and each piece is hashed independently. Based on the hashes of these pieces, one large hash is formed using a Merkle binary tree. This chunking allows for addressing the issue of parallel data processing during hash computation—for example, one can utilize 4-thread SIMD instructions to compute hashes for 4 blocks simultaneously. Traditional SHA-* hash functions process data sequentially.
Features of BLAKE3:
- High performance, BLAKE3 is significantly faster than MD5, SHA-1, SHA-2, SHA-3, and BLAKE2.
- Security, including resistance to length extension attacks, which SHA-2 is vulnerable to;
- Variants are available in Rust optimized for using SSE2, SSE4.1, AVX2, AVX-512, and NEON instructions.
- Ensuring parallel computation across any number of threads and SIMD lanes.
- Capability for incremental updating and verified stream processing;
- Application in modes PRF, MAC, KDF, XOF, and as a standard hash;
- A single algorithm for all architectures, fast on both x86-64 systems and 32-bit ARM processors.
Key differences between BLAKE3 and BLAKE2:
- Use of a binary tree structure that enables unlimited parallelism in hash computation.
- Reduction of the number of rounds from 10 to 7.
- Three modes of operation: hashing, keyed hashing (HMAC), and key formation (KDF).
- No additional overhead when hashing with a key due to the use of the area previously occupied by the key parameters block.
- Built-in mechanism operating as an Extendable Output Function (XOF) allowing for parallelization and seeking.
Source: opennet.ru
