Volver a actualizaciones
Nuevo releaseAug 20, 2026

BLAKE3 v1.8.7

Función hash criptográfica rápida con modos PRF, MAC, KDF y XOF. Soporta streaming verificado, actualizaciones incrementales y hashing paralelizado mediante estructura de árbol de Merkle.

Compartir

BLAKE3

BLAKE3 es una función hash criptográfica que:

  • Es mucho más rápida que MD5, SHA-1, SHA-2, SHA-3 y BLAKE2.
  • Es segura, a diferencia de MD5 y SHA-1. Y segura contra la extensión de longitud, a diferencia de SHA-2.
  • Es altamente paralelizable en cualquier número de hilos y carriles SIMD, porque internamente es un árbol de Merkle.
  • Capaz de transmisión verificada y actualizaciones incrementales, nuevamente porque es un árbol de Merkle.
  • Es una PRF, MAC, KDF y XOF, además de un hash normal.
  • Es un solo algoritmo sin variantes, que es rápido en x86-64 y también en arquitecturas más pequeñas.

El gráfico a continuación es un ejemplo de referencia de entradas de 16 KiB en un servidor CPU Cascade Lake-SP 8275CL de 2019. Para puntos de referencia más detallados, consulte el artículo de BLAKE3.

gráfico de rendimiento

BLAKE3 se basa en una instancia optimizada de la función hash establecida BLAKE2 y en el modo de árbol Bao original. Las especificaciones y el fundamento del diseño están disponibles en el artículo de BLAKE3. El tamaño de salida predeterminado es de 256 bits. La versión actual de Bao implementa transmisión verificada con BLAKE3.

Este repositorio es la implementación oficial de BLAKE3. Incluye:

  • La crate blake3 de Rust, que incluye implementaciones optimizadas para SSE2, SSE4.1, AVX2, AVX-512, NEON y WASM, con detección automática de características de CPU en tiempo de ejecución en x86. La característica rayon proporciona multiprocesamiento.

  • La crate b3sum de Rust, que proporciona una interfaz de línea de comandos. Utiliza multiprocesamiento de forma predeterminada, lo que lo hace un orden de magnitud más rápido que, por ejemplo, sha256sum en hardware de escritorio típico.

  • La implementación en C, que, como la implementación en Rust, incluye optimizaciones SIMD (todas excepto WASM), detección de características de CPU en x86 y multiprocesamiento opcional. Consulte c/README.md.

  • La implementación de referencia en Rust, que se analiza en la Sección 5.1 del artículo de BLAKE3. Esta implementación es mucho más pequeña y simple que las optimizadas anteriores. Si desea ver cómo funciona BLAKE3, o si está escribiendo un puerto que no necesita multiprocesamiento u optimizaciones SIMD, comience aquí. Los puertos de la implementación de referencia a otros lenguajes se alojan en repositorios separados (C, Python).

  • Un conjunto de vectores de prueba que cubre salidas extendidas, los tres modos y una variedad de longitudes de entrada.

  • Actions Status

BLAKE3 fue diseñado por:

El desarrollo de BLAKE3 fue patrocinado por Electric Coin Company.

BLAKE3 también está especificado en el Proyecto de Especificación Comunitaria de Criptografía (C2SP).

NOTA: BLAKE3 no es un algoritmo de hash de contraseñas, porque está diseñado para ser rápido, mientras que el hash de contraseñas no debe ser rápido. Si hashea contraseñas para almacenar los hashes o si deriva claves de contraseñas, recomendamos Argon2.

Uso

La utilidad b3sum

La utilidad de línea de comandos b3sum imprime los hashes BLAKE3 de archivos o de la entrada estándar. Los binarios precompilados están disponibles para Linux, Windows y macOS (que requiere la solución para desarrollador no identificado) en la página de lanzamientos. Si ha instalado Rust y Cargo, también puede compilar b3sum usted mismo con:

cargo install b3sum

Si rustup no configuró su PATH por usted, es posible que deba buscar el binario instalado en, por ejemplo, ~/.cargo/bin. Puede probar qué tan rápido es BLAKE3 en su máquina creando un archivo grande y hashándolo, por ejemplo:

# Crea un archivo de 1 GB.
head -c 1000000000 /dev/zero > /tmp/bigfile
# Haz hash con SHA-256.
time openssl sha256 /tmp/bigfile
# Haz hash con BLAKE3.
time b3sum /tmp/bigfile

La crate blake3 docs.rs

Para usar BLAKE3 desde código Rust, agregue una dependencia de la crate blake3 a su Cargo.toml. Aquí hay un ejemplo de hash de algunos bytes de entrada:

// Hash de una entrada de una sola vez.
let hash1 = blake3::hash(b"foobarbaz");

// Hash de una entrada de forma incremental.
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);

// Salida extendida. OutputReader también implementa Read y Seek.
let mut output = [0; 1000];
let mut output_reader = hasher.finalize_xof();
output_reader.fill(&mut output);
assert_eq!(hash1, output[..32]);

// Imprime un hash como hexadecimal.
println!("{}", hash1);

Además de hash, BLAKE3 proporciona otros dos modos, keyed_hash y derive_key. El modo keyed_hash toma una clave de 256 bits:

// MAC de una entrada de una sola vez.
let example_key = [42u8; 32];
let mac1 = blake3::keyed_hash(&example_key, b"example input");

// MAC de forma incremental.
let mut hasher = blake3::Hasher::new_keyed(&example_key);
hasher.update(b"example input");
let mac2 = hasher.finalize();
assert_eq!(mac1, mac2);

El modo derive_key toma una cadena de contexto y algún material clave (no una contraseña). La cadena de contexto debe estar codificada de forma fija, ser globalmente única y específica de la aplicación. Un buen formato predeterminado para la cadena de contexto es "[application] [commit timestamp] [purpose]":

// Deriva un par de subclaves para diferentes propósitos.
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);

La implementación en C

Consulte c/README.md.

Otras implementaciones

Hay demasiadas implementaciones para que podamos mantener un registro, pero algunos aspectos destacados incluyen una implementación Go optimizada, enlaces Wasm para Node.js y navegadores, ruedas binarias para Python, enlaces .NET y una implementación pura en Java.

Contribuir

Consulte CONTRIBUTING.md.

Licencias

Este trabajo se publica en el dominio público con CC0 1.0. Alternativamente, está licenciado bajo cualquiera de las siguientes:

Adopción e implementación

Miscelánea

Leer más

Categorías

Herramientas de Cifrado/DescifradoAnálisis de HashCriptografía