BLAKE (función hash)

BLAKE es una función hash criptográfica basada en el cifrado de flujo ChaCha de Daniel J. Bernstein , pero se agrega una copia permutada del bloque de entrada, XORed con constantes de ronda, antes de cada ronda de ChaCha. Al igual que SHA-2 , hay dos variantes que difieren en el tamaño de palabra . ChaCha opera en una matriz de palabras de 4 × 4. BLAKE combina repetidamente un valor hash de 8 palabras con 16 palabras de mensaje, truncando el resultado de ChaCha para obtener el siguiente valor hash. BLAKE-256 y BLAKE-224 usan palabras de 32 bits y producen tamaños de resumen de 256 bits y 224 bits, respectivamente, mientras que BLAKE-512 y BLAKE-384 usan palabras de 64 bits y producen tamaños de resumen de 512 bits y 384 bits, respectivamente.

La función hash BLAKE2, basada en BLAKE, se anunció en 2012. La función hash BLAKE3, basada en BLAKE2, se anunció en 2020.

Jean-Philippe Aumasson, Luca Henzen, Willi Meier y Raphael C.-W. Phan presentaron BLAKE al concurso de funciones hash del NIST . En 2008, hubo 51 participantes. BLAKE llegó a la ronda final, compuesta por cinco candidatos, pero perdió ante Keccak en 2012, que fue seleccionado por el algoritmo SHA-3 .

Al igual que SHA-2 , BLAKE viene en dos variantes: una que utiliza palabras de 32 bits, que se utilizan para calcular hashes de hasta 256 bits de longitud, y otra que utiliza palabras de 64 bits, que se utilizan para calcular hashes de hasta 512 bits de longitud. La transformación de bloques principal combina 16 palabras de entrada con 16 variables de trabajo, pero solo se conservan 8 palabras (256 o 512 bits) entre bloques.

Utiliza una tabla de 16 palabras constantes (los 512 o 1024 bits iniciales de la parte fraccionaria de π ) y una tabla de 10 permutaciones de 16 elementos:

σ[0] = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
s[1] = 14 10 4 8 9 15 13 6 1 12 0 2 11 7 5 3
s[2] = 11 8 12 0 5 2 15 13 10 14 3 6 7 1 9 4
σ[3] = 7 9 3 1 13 12 11 14 2 6 5 10 4 0 15 8
σ[4] = 9 0 5 7 2 4 10 15 14 1 11 12 6 8 3 13
σ[5] = 2 12 6 10 0 11 8 3 4 13 7 5 15 14 1 9
s[6] = 12 5 1 15 14 13 4 10 0 7 6 3 9 2 8 11
σ[7] = 13 11 7 14 12 1 3 9 5 0 15 4 8 6 2 10
s[8] = 6 15 14 9 11 3 0 8 12 2 13 7 1 4 10 5
σ[9] = 10 2 8 4 7 6 1 5 15 11 9 14 3 12 13 0

La operación central, equivalente al cuarto de ronda de ChaCha, opera sobre una columna o diagonal de 4 palabras a b c d, que se combina con 2 palabras de mensaje m[]y dos palabras constantes n[]. Se realiza 8 veces por ronda completa:

j ← σ[r%10][2×i]             // Cálculos de índice
k ← σ[r%10][2×i+1]
a ← a + b + (m[j] ⊕ n[k])    // Paso 1 (con entrada)
d ← (d ⊕ a) >>> 16
c ← c + d                    // Paso 2 (sin entrada)
b ← (b ⊕ c) >>> 12
a ← a + b + (m[k] ⊕ n[j])    // Paso 3 (con entrada)
d ← (d ⊕ a) >>> 8
c ← c + d                    // Paso 4 (sin entrada)
b ← (b ⊕ c) >>> 7

En la imagen de arriba, res un número redondo (0–13) y ivaría de 0 a 7.

Las diferencias con la función de cuarto de vuelta de ChaCha son:

• Se ha añadido la adición de palabras del mensaje.
• Se han invertido las direcciones de rotación.

"BLAKE reutiliza la permutación del cifrado de flujo ChaCha con rotaciones realizadas en direcciones opuestas. Algunos han sospechado una optimización avanzada, pero en realidad se origina a partir de un error tipográfico en las especificaciones originales de BLAKE", explica Jean-Philippe Aumasson en su "Diccionario de criptografía". ^[1]

La versión de 64 bits (que no existe en ChaCha) es idéntica, pero las cantidades de rotación son 32, 25, 16 y 11, respectivamente, y el número de rondas aumenta a 16.

Durante la competición de funciones hash del NIST, los participantes pueden "modificar" sus algoritmos para solucionar los problemas que se descubran. Los cambios que se han realizado en BLAKE son: el número de rondas se ha incrementado de 10/14 a 14/16. Esto es para ser más conservadores en cuanto a la seguridad y al mismo tiempo ser rápidos.

Valores hash de una cadena vacía:

BLAKE-224("") =
7dc5313b1c04512a174bd6503b89607aecbee0903d40a8a569c94eed
BLAKE-256("") =
716f6e863f744b9ac22c97ec7b76ea5f5908bc5b2f67c61510bfc4751384ea7a
BLAKE-384("") =
c6cbd89c926ab525c242e6621f2f5fa73aa4afe3d9e24aed727faaadd6af38b620bdb623dd2b4788b1c8086984af8706
BLAKE-512("") =
a8cfbbd73726062df0c6864dda65defe58ef0cc52a5625090fa17601e1eecd1b628e94f396ae402a00acc9eab77b4d4c2e852aaaa25a636d80af3fc7913ef5b8

Cambiar un solo bit hace que cada bit de la salida cambie con un 50 % de probabilidad, lo que demuestra un efecto de avalancha :

BLAKE-512("El rápido zorro marrón salta sobre el perro perezoso") =
1f7e26f63b6ad25a0896fd978fd050a1766391d2fd0471a77afb975e5034b7ad2d9ccf8dfb47abbbe656e1b82fbc634ba42ce186e8dc5e1ce09a885d41f43451
BLAKE-512("El rápido zorro marrón salta sobre el perezoso do f ") =
a701c2a1f9baabd8b1db6b75aee096900276f0b86dc15d247ecc03937b370324a16a4ffc0c3a85cd63229cfa15c15f4ba6d46ae2e849ed6335e9ff43b764198a

(En este ejemplo, 266 bits coincidentes de 512 son aproximadamente el 52% debido a la naturaleza aleatoria de la avalancha).

BLAKE2 es una función hash criptográfica basada en BLAKE, creada por Jean-Philippe Aumasson, Samuel Neves, Zooko Wilcox-O'Hearn y Christian Winnerlein. El objetivo del diseño era reemplazar los algoritmos MD5 y SHA-1 , ampliamente utilizados pero defectuosos, en aplicaciones que requieren un alto rendimiento en el software. BLAKE2 se anunció el 21 de diciembre de 2012. ^[3] Una implementación de referencia está disponible bajo CC0 , la licencia OpenSSL y la licencia Apache 2.0 . ^{[4] [5]}

BLAKE2b es más rápido que MD5, SHA-1, SHA-2 y SHA-3 en arquitecturas ARM y x86-64 de 64 bits. ^[4] BLAKE2 proporciona una mejor seguridad que SHA-2 y similar a la de SHA-3: inmunidad a la extensión de longitud , indiferenciabilidad de un oráculo aleatorio, etc. ^[6]

BLAKE2 elimina la adición de constantes a las palabras del mensaje de la función de ronda BLAKE, cambia dos constantes de rotación, simplifica el relleno, agrega un bloque de parámetros que se XORiza con vectores de inicialización y reduce la cantidad de rondas de 16 a 12 para BLAKE2b (sucesor de BLAKE-512), y de 14 a 10 para BLAKE2s (sucesor de BLAKE-256).

BLAKE2 admite modos de codificación, salazón, personalización y árbol hash, y puede generar resúmenes de entre 1 y 64 bytes para BLAKE2b, o hasta 32 bytes para BLAKE2s. También existen versiones paralelas diseñadas para un mayor rendimiento en procesadores multinúcleo : BLAKE2bp (paralelo de 4 vías) y BLAKE2sp (paralelo de 8 vías).

BLAKE2X es una familia de funciones de salida extensible (XOF). Mientras que BLAKE2 está limitado a resúmenes de 64 bytes, BLAKE2X permite resúmenes de hasta 256 GiB. BLAKE2X en sí no es una instancia de una función hash y debe basarse en una instancia real de BLAKE2. Un ejemplo de una instancia de BLAKE2X podría ser BLAKE2Xb16MiB , que sería una versión de BLAKE2X basada en BLAKE2b que produce resúmenes de 16 777 216 bytes (o exactamente 16 MiB , de ahí el nombre de dicha instancia). ^[7]

BLAKE2b y BLAKE2s se especifican en RFC 7693. Las características opcionales que utilizan el bloque de parámetros (sal, hashes personalizados, hashes de árbol, etcétera) no se especifican y, por lo tanto, tampoco se admite BLAKE2bp, BLAKE2sp o BLAKE2X. ^[8]

BLAKE2b utiliza un vector de inicialización que es el mismo que el IV utilizado por SHA-512. Estos valores se obtienen de forma transparente tomando los primeros 64 bits de las partes fraccionarias de las raíces cuadradas positivas de los primeros ocho números primos.

IV 0 = 0x6a09e667f3bcc908    // Frac(raíz(2)) 
IV 1 = 0xbb67ae8584caa73b    // Frac(raíz(3)) 
IV 2 = 0x3c6ef372fe94f82b    // Frac(raíz(5)) 
IV 3 = 0xa54ff53a5f1d36f1    // Frac(raíz(7)) 
IV 4 = 0x510e527fade682d1    // Frac(raíz(11)) 
IV 5 = 0x9b05688c2b3e6c1f    // Frac(raíz(13)) 
IV 6 = 0x1f83d9abfb41bd6b    // Frac(raíz(17)) 
IV 7 = 0x5be0cd19137e2179    // Frac(raíz cuadrada(19))

Pseudocódigo para el algoritmo BLAKE2b. El algoritmo BLAKE2b utiliza palabras de 8 bytes (UInt64) y fragmentos de 128 bytes.

Algoritmo BLAKE2b
    Entrada: 
      M                                Mensaje a codificar 
      cbMessageLen: Número, (0..2 128 )   Longitud del mensaje en bytes Clave 
      Clave                              opcional de 0..64 bytes 
      cbKeyLen: Número, (0..64)        Longitud de la clave opcional en bytes 
      cbHashLen: Número, (1..64)       Longitud de hash deseada en bytes 
   Salida: 
      Hash                             Hash de cbHashLen bytes

   Inicializar el vector de estado h con IV 
   h 0..7 ← IV 0..7

   Mezcle el tamaño de la clave (cbKeyLen) y la longitud de hash deseada (cbHashLen) en h 0 
   h 0 ← h 0 xor 0x0101kknn
          donde kk es la longitud de la clave (en bytes) 
               nn  es la longitud de hash deseada (en bytes)

   Cada vez que comprimimos, registramos cuántos bytes se han comprimido.
   cBytesComprimido ← 0
   cBytes restantes ← cbMessageLen

   Si se proporcionó una clave (es decir, cbKeyLen > 0)  
   , rellene con ceros finales para que tenga 128 bytes (es decir, 16 palabras) 
   y antepóngala al mensaje M
    si (cbKeyLen > 0) entonces
      M ← Pad(Tecla, 128) || M
      cBytes restantes ← cBytes restantes + 128
   terminar si

   Comprime fragmentos completos de 128 bytes del mensaje, excepto el último fragmento 
   while (cBytesRemaining > 128) do 
      chunk ← obtiene los siguientes 128 bytes del mensaje M 
      cBytesCompressed ← cBytesCompressed + 128   aumenta el recuento de bytes que se han comprimido 
      cBytesRemaining ← cBytesRemaining - 128   disminuye el recuento de bytes en M que quedan por procesar

      h ← Compress(h, chunk, cBytesCompressed, false)   false ⇒ este no es el último fragmento 
   end while

   Comprimir los bytes finales del fragmento M 
   ← obtener los siguientes 128 bytes del mensaje M   Obtendremos cBytesRemaining bytes (es decir, 0..128 bytes) 
   cBytesCompressed ← cBytesCompressed+cBytesRemaining   La cantidad real de bytes restantes en el fragmento M 
   ← Pad(fragmento, 128)   Si M estaba vacío, entonces comprimiremos un fragmento final de ceros

   h ← Compress(h, chunk, cBytesCompressed, true)   true ⇒ este es el último fragmento

   Resultado ← primeros bytes cbHashLen del vector de estado little endian h
 Fin del algoritmo BLAKE2b

La función Compress toma un fragmento completo de 128 bytes del mensaje de entrada y lo mezcla en la matriz de estado en curso:

Función Comprimir
    Entrada: 
      h                      
      Fragmento                   de vector de estado persistente Fragmento de 128 bytes (16 palabras dobles) del mensaje a comprimir 
      t: Número, 0..2 128      Cantidad de bytes que se han introducido en la compresión 
      IsLastBlock: Booleano    Indica si esta es la ronda final de compresión Salida 
   : 
      h                       Vector de estado persistente actualizado

   Configurar el vector de trabajo local V 
   V 0..7 ← h 0..7    Los primeros ocho elementos se copian del vector de estado persistente h 
   V 8..15 ← IV 0..7  Los ocho elementos restantes se inicializan desde el IV

   Mezclar el contador de 128 bits t en V 12 :V 13 
   V 12 ← V 12  xor Lo(t)     Lo 64 bits de UInt128 t 
   V 13 ← V 13  xor Hi(t)     Hi 64 bits de UInt128 t
  
   Si este es el último bloque, entonces invierta todos los bits en V 14
    si IsLastBlock entonces 
      V 14 ← V 14  xor 0xFFFFFFFFFFFFFFFF
   
   Trate cada fragmento de mensaje de 128 bytes como dieciséis palabras de 8 bytes (64 bits) m 
   m 0..15 ← fragmento

   Doce rondas de mezcla de mensajes criptográficos 
   para i de 0 a 11 hacen 
      Seleccione el programa de mezcla de mensajes para esta ronda. 
       BLAKE2b usa 12 rondas, mientras que SIGMA tiene solo 10 entradas. 
      S 0..15 ← SIGMA[i mod 10]    Las rondas 10 y 11 usan SIGMA[0] y SIGMA[1] respectivamente

      Mezclar(V 0 , V 4 , V 8 , V 12 , m[S 0 ], m[S 1 ])
      Mezclar(V 1 , V 5 , V 9 , V 13 , m[S 2 ], m[S 3 ])
      Mezclar(V 2 , V 6 , V 10 , V 14 , m[S 4 ], m[S 5 ])
      Mezclar(V 3 , V 7 , V 11 , V 15 , m[S 6 ], m[S 7 ])

      Mezclar(V 0 , V 5 , V 10 , V 15 , m[S 8 ], m[S 9 ])
      Mezclar(V 1 , V 6 , V 11 , V 12 , m[S 10 ], m[S 11 ])
      Mezclar(V 2 , V 7 , V 8 , V 13 , m[S 12 ], m[S 13 ])
      Mix(V 3 , V 4 , V 9 , V 14 , m[S 14 ], m[S 15 ])
    fin para

   Mezclar las mitades superior e inferior de V en el vector de estado continuo h 
   h 0..7 ← h 0..7  xor V 0..7 
   h 0..7 ← h 0..7  xor V 8..15

   Resultado ← h
 Fin Función Comprimir

La función Mix es llamada por la función Compress y mezcla dos palabras de 8 bytes del mensaje en el estado hash. En la mayoría de las implementaciones, esta función se escribiría en línea o como una función en línea.

Función Mix
    Entradas: 
        V a , V b , V c , V d        cuatro entradas de palabras de 8 bytes del vector de trabajo V 
        x, y                 dos entradas de palabras de 8 bytes del mensaje rellenado m 
   Salida: 
        V a , V b , V c , V d        las versiones modificadas de V a , V b , V c , V d

   V a ← V a + V b + x           con entrada 
   V d ← (V d  x o V a ) rotar a la derecha 32

   V c ← V c + V d               sin entrada 
   V b ← (V b  xor V c ) rotar a la derecha 24

   V a ← V a + V b + y           con entrada 
   V d ← (V d  xor V a ) rotateright 16

   V c ← V c + V d               sin entrada 
   V b ← (V b  xor V c ) rotar a la derecha 63

   Resultado ← V a , V b , V c , V d 
Función final Mix

Valores hash de una cadena vacía:

BLAKE2s-224("") =
1fa1291e65248b37b3433475b2a0dd63d54a11ecc4e3e034e7bc1ef4
BLAKE2s-256("") =
69217a3079908094e11121d042354a7c1f55b6482ca1a51e1b250dfd1ed0eef9
BLAKE2b-384("") =
b32811423377f52d7862286ee1a72ee540524380fda1724a6f25d7978c6fd3244a6caf0498812673c5e05ef583825100
BLAKE2b-512("") =
786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce

Cambiar un solo bit hace que cada bit de la salida cambie con un 50 % de probabilidad, lo que demuestra un efecto de avalancha :

BLAKE2b-512("El rápido zorro marrón salta sobre el perro perezoso") =
a8add4bdddfd93e4877d2746e62817b116364a1fa7bc148d95090bc7333b3673f82401cf7aa2e4cb1ecd90296e3f14cb5413f8ed77be73045b13914cdcd6a918
BLAKE2b-512("El rápido zorro marrón salta sobre el perezoso do f ") =
ab6b007747d8068c02e25a6008db8a77c218d94f3b40d2291a7dc8a62090a744c082ea27af01521a102e42f480a31e9844053f456b4b41e8aa78bbe5c12957bb

• Argon2 , el ganador del concurso de hash de contraseñas , utiliza BLAKE2b
• El sistema de implementación de Habitat de Chef utiliza BLAKE2b para la firma de paquetes ^[9]
• La herramienta de gestión de paquetes de puertos de FreeBSD utiliza BLAKE2b
• GNU Core Utilities implementa BLAKE2b en su comando b2sum ^[10]
• IPFS permite el uso de BLAKE2b para el hash de árboles
• librsync utiliza BLAKE2b ^[11]
• Noise (protocolo criptográfico) que se utiliza en WhatsApp incluye BLAKE2 como opción. ^{[12] [ cita requerida ]}
• La versión 5 del formato de archivo RAR admite una suma de comprobación de archivo BLAKE2sp opcional de 256 bits en lugar del CRC32 de 32 bits predeterminado ; se implementó en WinRAR v5+ ^[13]
• 7-Zip (para soportar el formato de archivo RAR versión 5 ^[14] ) puede generar la firma BLAKE2sp para cada archivo en el shell del Explorador a través del menú contextual "CRC SHA" y eligiendo '*'
• rmlint utiliza BLAKE2b para la detección de archivos duplicados ^[15]
• WireGuard utiliza BLAKE2 para hash ^[16]
• Zcash , una criptomoneda, utiliza BLAKE2b en la prueba de trabajo de Equihash y como función de derivación de clave.
• NANO , una criptomoneda, utiliza BLAKE2b en la prueba de trabajo, para el hash de firmas digitales y como función de derivación de clave ^{[17] [18] [19]}
• Polkadot , una cadena de bloques multicadena, utiliza BLAKE2b como su algoritmo hash.
• Kadena (criptomoneda), una cadena de bloques de prueba de trabajo escalable que utiliza Blake2s_256 como algoritmo hash.
• PCI Vault utiliza BLAKE2b como su algoritmo hash con el propósito de tokenización de PCD compatible con PCI.
• Ergo, una criptomoneda, utiliza BLAKE2b256 como una subrutina de su algoritmo hash llamado Autolykos. ^[20]
• El kernel de Linux , versión 5.17 reemplazó SHA-1 con BLAKE2 para hacer hashes del pool de entropía en el generador de números aleatorios . ^[21]
• Open Network for Digital Commerce , una iniciativa del Gobierno de la India, utiliza BLAKE-512 para firmar solicitudes API. ^[22]
• checksum , un programa de hash de archivos de Windows tiene a Blake2s como uno de sus algoritmos ^[23]

Además de la implementación de referencia, ^[5] las siguientes bibliotecas de criptografía proporcionan implementaciones de BLAKE2:

• Botánica
• Castillo inflable
• Criptomoneda++
• Libgcrypt
• libsodio
• OpenSSL
• lobo SSL

BLAKE3 es una función hash criptográfica basada en Bao y BLAKE2, creada por Jack O'Connor, Jean-Philippe Aumasson, Samuel Neves y Zooko Wilcox-O'Hearn . ^[25] Fue anunciada el 9 de enero de 2020 en Real World Crypto . ^[26]

BLAKE3 es un algoritmo único con muchas características deseables (paralelismo, XOF , KDF , PRF y MAC ), en contraste con BLAKE y BLAKE2, que son familias de algoritmos con múltiples variantes. BLAKE3 tiene una estructura de árbol binario , por lo que admite un grado prácticamente ilimitado de paralelismo (tanto SIMD como multihilo) si se le da una entrada lo suficientemente larga. Las implementaciones oficiales de Rust y C ^[27] tienen licencia dual como dominio público ( CC0 ) y la licencia Apache . ^[28]

BLAKE3 está diseñado para ser lo más rápido posible. Es consistentemente varias veces más rápido que BLAKE2. La función de compresión de BLAKE3 se basa estrechamente en la de BLAKE2, con la mayor diferencia siendo que el número de rondas se reduce de 10 a 7, un cambio basado en el supuesto de que la criptografía actual es demasiado conservadora. ^[29] Además de proporcionar paralelismo, el formato de árbol de Merkle también permite la transmisión verificada (verificación sobre la marcha) y actualizaciones incrementales. ^[27]

• El sitio web de BLAKE
• El sitio web de BLAKE2
• El sitio web de BLAKE3