stringtranslate.com

Salsa20

Salsa20 y el estrechamente relacionado ChaCha son cifrados de flujo desarrollados por Daniel J. Bernstein . Salsa20, el cifrado original, fue diseñado en 2005 y luego enviado al proceso de validación criptográfica de la Unión Europea eSTREAM por Bernstein. ChaCha es una modificación de Salsa20 publicada en 2008. Utiliza una nueva función de ronda que aumenta la difusión y el rendimiento en algunas arquitecturas. [4]

Ambos cifrados se basan en una función pseudoaleatoria basada en operaciones de suma-rotación-XOR (ARX): suma de 32 bits, suma bit a bit (XOR) y operaciones de rotación . La función principal asigna una clave de 256 bits , un nonce de 64 bits y un contador de 64 bits a un bloque de 512 bits del flujo de claves (también existe una versión de Salsa con una clave de 128 bits). Esto le da a Salsa20 y ChaCha la ventaja inusual de que el usuario puede buscar de manera eficiente cualquier posición en el flujo de claves en tiempo constante. Salsa20 ofrece velocidades de alrededor de 4 a 14 ciclos por byte en software en procesadores x86 modernos [5] y un rendimiento de hardware razonable. No está patentado y Bernstein ha escrito varias implementaciones de dominio público optimizadas para arquitecturas comunes [6] .

Estructura

Internamente, el cifrado utiliza la suma bit a bit ⊕ ( OR exclusivo ), la suma de 32 bits módulo 2 32 ⊞ y las operaciones de rotación de distancia constante <<< sobre un estado interno de dieciséis palabras de 32 bits. El uso exclusivo de operaciones de suma-rotación-xor evita la posibilidad de ataques de tiempo en las implementaciones de software. El estado interno está formado por dieciséis palabras de 32 bits dispuestas como una matriz de 4×4.

El estado inicial se compone de ocho palabras clave ( ), dos palabras de posición de flujo ( ), dos palabras de nonce (esencialmente bits de posición de flujo adicionales) ( ), y cuatro palabras fijas ( ):

Las palabras constantes forman la forma "expand 32-byte k" en ASCII (es decir, las 4 palabras son "expa", "nd 3", "2-by" y "te k"). Este es un ejemplo de un número que no tiene nada bajo la manga . La operación principal en Salsa20 es el cuarto de vuelta QR(a, b, c, d)que toma una entrada de cuatro palabras y produce una salida de cuatro palabras:

b ^= (a + d) <<< 7;c ^= (b + a) <<< 9;d ^= (c + b) <<< 13;a ^= (d + c) <<< 18;

Las rondas impares se aplican QR(a, b, c, d)a cada una de las cuatro columnas de la matriz 4×4, y las rondas pares se aplican a cada una de las cuatro filas. Dos rondas consecutivas (ronda de columnas y ronda de filas) se denominan ronda doble:

// Ronda imparQR( 0, 4, 8, 12) // columna 1QR(5, 9, 13, 1) // columna 2QR(10, 14, 2, 6) // columna 3QR(15, 3, 7, 11) // columna 4// Redondo uniformeQR( 0, 1, 2, 3) // fila 1QR( 5, 6, 7, 4) // fila 2QR(10, 11, 8, 9) // fila 3QR(15, 12, 13, 14) // fila 4

A continuación aparece una implementación en C/C++.

#include <stdint.h> #define ROTL(a,b) (((a) << (b)) | ((a) >> (32 - (b)))) #define QR(a, b, c, d)( \ b ^= ROTL(a + d, 7), \ c ^= ROTL(b + a, 9), \ d ^= ROTL(c + b,13), \ a ^= ROTL(d + c,18)) #define RONDAS 20 void salsa20_block ( uint32_t salida [ 16 ], uint32_t const en [ 16 ]) { int i ; uint32_t x [ 16 ];       para ( i = 0 ; i < 16 ; ++ i ) x [ i ] = en [ i ]; // 10 bucles × 2 rondas/bucle = 20 rondas para ( i = 0 ; i < ROUNDS ; i += 2 ) { // Ronda impar QR ( x [ 0 ], x [ 4 ], x [ 8 ], x [ 12 ]); // columna 1 QR ( x [ 5 ], x [ 9 ], x [ 13 ], x [ 1 ]); // columna 2 QR ( x [ 10 ], x [ 14 ], x [ 2 ], x [ 6 ]); // columna 3 QR ( x [ 15 ], x [ 3 ], x [ 7 ], x [ 11 ]); // columna 4 // Ronda par QR ( x [ 0 ], x [ 1 ], x [ 2 ], x [ 3 ]); // fila 1 QR ( x [ 5 ], x [ 6 ], x [ 7 ], x [ 4 ]); // fila 2 QR ( x [ 10 ], x [ 11 ], x [ 8 ], x [ 9 ]); // fila 3 QR ( x [ 15 ], x [ 12 ], x [ 13 ], x [ 14 ]); // fila 4 } for ( i = 0 ;                                                                           i < 16 ; ++ i ) salida [ i ] = x [ i ] + entrada [ i ]; }       

En la última línea, la matriz mixta se agrega, palabra por palabra, a la matriz original para obtener su bloque de flujo de clave de 64 bytes. Esto es importante porque las rondas de mezcla por sí solas son invertibles . En otras palabras, aplicar las operaciones inversas produciría la matriz original de 4 × 4, incluida la clave. Agregar la matriz mixta a la original hace que sea imposible recuperar la entrada. (Esta misma técnica se usa ampliamente en funciones hash desde MD4 hasta SHA-2 ).

Salsa20 realiza 20 rondas de mezcla en su entrada. [1] Sin embargo, también se han introducido variantes de ronda reducida Salsa20/8 y Salsa20/12 que utilizan 8 y 12 rondas respectivamente. Estas variantes se introdujeron para complementar al Salsa20 original, no para reemplazarlo, y funcionan mejor [nota 1] en los puntos de referencia eSTREAM que Salsa20, aunque con un margen de seguridad correspondientemente menor.

XSalsa20 con nonce de 192 bits

En 2008, Bernstein propuso una variante de Salsa20 con nonces de 192 bits llamada XSalsa20. [7] [8] [9] XSalsa20 es demostrablemente seguro si Salsa20 es seguro, pero es más adecuado para aplicaciones donde se desean nonces más largos. XSalsa20 alimenta la clave y los primeros 128 bits del nonce en un bloque de Salsa20 (sin la adición final, que puede omitirse o restarse después de un bloque Salsa20 estándar), y utiliza 256 bits de la salida como la clave para Salsa20 estándar utilizando los últimos 64 bits del nonce y la posición del flujo. Específicamente, los 256 bits de salida utilizados son los correspondientes a las partes no secretas de la entrada: índices 0, 5, 10, 15, 6, 7, 8 y 9.

Selección eSTREAM de Salsa20

Salsa20/12 ha sido seleccionado como un diseño de Fase 3 para el Perfil 1 (software) por el proyecto eSTREAM , recibiendo la puntuación de votación ponderada más alta de todos los algoritmos del Perfil 1 al final de la Fase 2. [10] Salsa20 había sido seleccionado previamente como un diseño de Enfoque de Fase 2 para el Perfil 1 (software) y como un diseño de Fase 2 para el Perfil 2 (hardware) por el proyecto eSTREAM, [11] pero no avanzó a la Fase 3 para el Perfil 2 porque eSTREAM consideró que probablemente no era un buen candidato para entornos de hardware con recursos extremadamente limitados. [12]

El comité eSTREAM recomienda el uso de Salsa20/12, la variante de 12 rondas, por "combinar un muy buen rendimiento con un cómodo margen de seguridad". [13]

Criptoanálisis de Salsa20

A partir de 2015 , no hay ataques publicados sobre Salsa20/12 o el Salsa20/20 completo; el mejor ataque conocido [3] rompe 8 de las 12 o 20 rondas.

En 2005, Paul Crowley informó de un ataque a Salsa20/5 con una complejidad temporal estimada de 2 165 y ganó el premio Bernstein de 1000 dólares estadounidenses por "criptoanálisis de Salsa20 más interesante". [14] Este ataque y todos los ataques posteriores se basan en criptoanálisis diferencial truncado . En 2006, Fischer, Meier, Berbain, Biasse y Robshaw informaron de un ataque a Salsa20/6 con una complejidad temporal estimada de 2 177 y de un ataque de clave relacionada a Salsa20/7 con una complejidad temporal estimada de 2 217. [15 ]

En 2007, Tsunoo et al. anunciaron un criptoanálisis de Salsa20 que rompe 8 de 20 rondas para recuperar la clave secreta de 256 bits en 2 255 operaciones, utilizando 2 pares de flujo de claves de 11,37 . [16] Sin embargo, este ataque no parece ser competitivo con el ataque de fuerza bruta.

En 2008, Aumasson, Fischer, Khazaei, Meier y Rechberger informaron sobre un ataque criptoanalítico contra Salsa20/7 con una complejidad temporal de 2 151 , y sobre un ataque contra Salsa20/8 con una complejidad temporal estimada de 2 251 . Este ataque hace uso del nuevo concepto de bits de clave neutrales probabilísticos para la detección probabilística de un diferencial truncado. El ataque se puede adaptar para romper Salsa20/7 con una clave de 128 bits. [3]

En 2012, el ataque de Aumasson et al. fue mejorado por Shi et al. contra Salsa20/7 (clave de 128 bits) a una complejidad de tiempo de 2 109 y Salsa20/8 (clave de 256 bits) a 2 250. [ 17]

En 2013, Mouha y Preneel publicaron una prueba [18] de que 15 rondas de Salsa20 eran seguras a 128 bits contra el criptoanálisis diferencial . (En concreto, no tiene ninguna característica diferencial con una probabilidad mayor que 2 −130 , por lo que el criptoanálisis diferencial sería más difícil que el agotamiento de la clave de 128 bits).

Variante de ChaCha

En 2008, Bernstein publicó la familia de cifrados ChaCha , estrechamente relacionada , que tiene como objetivo aumentar la difusión por ronda y lograr el mismo rendimiento o ligeramente mejor. [19] El artículo de Aumasson et al. también ataca a ChaCha, logrando una ronda menos (para ChaCha6 de 256 bits con complejidad 2 139 , ChaCha7 con complejidad 2 248 y ChaCha6 de 128 bits dentro de 2 107 ) pero afirma que el ataque no logra romper ChaCha7 de 128 bits. [3]

Al igual que Salsa20, el estado inicial de ChaCha incluye una constante de 128 bits, una clave de 256 bits, un contador de 64 bits y un nonce de 64 bits (en la versión original; como se describe más adelante, una versión de ChaCha de RFC  7539 es ligeramente diferente), organizados como una matriz 4×4 de palabras de 32 bits. [19] Pero ChaCha reorganiza algunas de las palabras en el estado inicial:

La constante es la misma que la de Salsa20 ("expandir k a 32 bytes"). ChaCha reemplaza el cuarto de vuelta de Salsa20 QR(a, b, c, d)por:

a += b; d ^= a; d <<<= 16;c + = d; b ^ = c; b <<<= 12;a += b; d ^= a; d <<<= 8;c + = d; b ^ = c; b <<<= 7;

Tenga en cuenta que esta versión actualiza cada palabra dos veces, mientras que el cuarto de vuelta de Salsa20 actualiza cada palabra solo una vez. Además, el cuarto de vuelta de ChaCha difunde los cambios más rápidamente. En promedio, después de cambiar 1 bit de entrada, el cuarto de vuelta de Salsa20 cambiará 8 bits de salida, mientras que ChaCha cambiará 12,5 bits de salida. [4]

El cuarto de vuelta de ChaCha tiene la misma cantidad de adiciones, xors y rotaciones de bits que el cuarto de vuelta de Salsa20, pero el hecho de que dos de las rotaciones sean múltiplos de 8 permite una pequeña optimización en algunas arquitecturas, incluida x86. [20] Además, el formato de entrada se ha reorganizado para admitir una optimización de implementación de SSE eficiente descubierta para Salsa20. En lugar de alternar redondeos hacia abajo en las columnas y a lo largo de las filas, se realizan hacia abajo en las columnas y a lo largo de las diagonales. [4] : 4  Al igual que Salsa20, ChaCha organiza las dieciséis palabras de 32 bits en una matriz de 4 × 4. Si indexamos los elementos de la matriz de 0 a 15

Entonces una ronda doble en ChaCha es:

// Ronda imparQR(0, 4, 8, 12) // columna 1QR(1, 5, 9, 13) // columna 2QR(2, 6, 10, 14) // columna 3QR(3, 7, 11, 15) // columna 4// Redondo uniformeQR(0, 5, 10, 15) // diagonal 1 (diagonal principal)QR(1, 6, 11, 12) // diagonal 2QR(2, 7, 8, 13) // diagonal 3QR(3, 4, 9, 14) // diagonal 4

ChaCha20 utiliza 10 iteraciones de la ronda doble. [21] A continuación aparece una implementación en C/C++.

#define ROTL(a,b) (((a) << (b)) | ((a) >> (32 - (b)))) #define QR(a, b, c, d) ( \ a += b, d ^= a, d = ROTL(d, 16), \ c += d, b ^= c, b = ROTL(b, 12), \ a += b, d ^= a, d = ROTL(d, 8), \ c += d, b ^= c, b = ROTL(b, 7)) #define RONDAS 20vacío chacha_block ( uint32_t salida [ 16 ], uint32_t const en [ 16 ]) { int i ; uint32_t x [ 16 ];       para ( i = 0 ; i < 16 ; ++ i ) x [ i ] = en [ i ]; // 10 bucles × 2 rondas/bucle = 20 rondas para ( i = 0 ; i < ROUNDS ; i += 2 ) { // Ronda impar QR ( x [ 0 ], x [ 4 ], x [ 8 ], x [ 12 ]); // columna 1 QR ( x [ 1 ], x [ 5 ], x [ 9 ], x [ 13 ]); // columna 2 QR ( x [ 2 ], x [ 6 ], x [ 10 ], x [ 14 ]); // columna 3 QR ( x [ 3 ], x [ 7 ], x [ 11 ], x [ 15 ]); // columna 4 // Ronda par QR ( x [ 0 ], x [ 5 ], x [ 10 ], x [ 15 ]); // diagonal 1 (diagonal principal) QR ( x [ 1 ], x [ 6 ], x [ 11 ], x [ 12 ]); // diagonal 2 QR ( x [ 2 ], x [ 7 ], x [ 8 ], x [ 13 ]); // diagonal 3 QR ( x [ 3 ], x [ 4 ], x [ 9 ], x [ 14 ]); // diagonal 4 } for ( i =                                                          0 ; i < 16 ; ++ i ) salida [ i ] = x [ i ] + entrada [ i ]; }        

ChaCha es la base de la función hash BLAKE , finalista en la competencia de funciones hash del NIST , y sus sucesoras más rápidas BLAKE2 y BLAKE3. También define una variante que utiliza dieciséis palabras de 64 bits (1024 bits de estado), con constantes de rotación ajustadas correspondientemente.

XChaCha

Aunque Bernstein no lo anunció, la prueba de seguridad de XSalsa20 se extiende directamente a un cifrado XChaCha análogo . Use la clave y los primeros 128 bits del nonce (en las palabras de entrada 12 a 15) para formar un bloque de entrada ChaCha, luego realice la operación de bloque (omitiendo la adición final). Las palabras de salida 0 a 3 y 12 a 15 (las palabras que corresponden a palabras no clave de la entrada) luego forman la clave utilizada para ChaCha ordinario (con los últimos 64 bits del nonce y 64 bits del contador de bloque). [22]

ChaCha redondo reducido

Aumasson sostiene en 2020 que 8 rondas de ChaCha (ChaCha8) probablemente brindan suficiente resistencia al criptoanálisis futuro para el mismo nivel de seguridad , lo que produce una aceleración de 2,5x. [23] Un ChaCha12 de compromiso (basado en la recomendación de eSTREAM de un Salsa de 12 rondas) [24] también tiene algún uso. [25] La suite de evaluación comparativa eSTREAM incluye ChaCha8 y ChaCha12. [19]

Adopción de ChaCha20

Google había seleccionado ChaCha20 junto con el código de autenticación de mensajes Poly1305 de Bernstein en SPDY , que estaba pensado como reemplazo de TLS sobre TCP . [26] En el proceso, propusieron una nueva construcción de cifrado autenticado que combina ambos algoritmos, que se llama ChaCha20-Poly1305 . ChaCha20 y Poly1305 ahora se utilizan en el protocolo QUIC , que reemplaza a SPDY y es utilizado por HTTP/3 . [27] [28]

Poco después de que Google adoptara TLS, los algoritmos ChaCha20 y Poly1305 también se usaron para un nuevo [email protected]cifrado en OpenSSH . [29] [30] Posteriormente, esto hizo posible que OpenSSH evitara cualquier dependencia de OpenSSL , a través de una opción de tiempo de compilación. [31]

ChaCha20 también se utiliza para el arc4randomgenerador de números aleatorios en los sistemas operativos FreeBSD , [32] OpenBSD , [33] y NetBSD [34] , en lugar del RC4 roto , y en DragonFly BSD [35] para la subrutina CSPRNG del núcleo. [36] [37] A partir de la versión 4.8, el núcleo de Linux utiliza el algoritmo ChaCha20 para generar datos para el dispositivo no bloqueante /dev/urandom . [38] [39] [40] ChaCha8 se utiliza para el PRNG predeterminado en Golang . [41] El CSPRNG de Rust utiliza ChaCha12. [24]

ChaCha20 suele ofrecer un mejor rendimiento que el algoritmo Advanced Encryption Standard (AES) más frecuente en sistemas donde la CPU no cuenta con aceleración AES (como el conjunto de instrucciones AES para procesadores x86). Como resultado, a veces se prefiere ChaCha20 sobre AES en ciertos casos de uso que involucran dispositivos móviles , que en su mayoría usan CPU basadas en ARM . [42] [43] Los aceleradores de hardware especializados para ChaCha20 también son menos complejos en comparación con los aceleradores AES. [44]

ChaCha20-Poly1305 (versión IETF; ver más abajo) es el algoritmo exclusivo utilizado por el sistema VPN WireGuard , a partir de la versión 1 del protocolo. [45]

Estándares de Internet

Se ha publicado una referencia de implementación para ChaCha20 en RFC  7539. La implementación de la IETF modificó el algoritmo publicado de Bernstein al cambiar el nonce de 64 bits y el contador de bloques de 64 bits a un nonce de 96 bits y un contador de bloques de 32 bits. [46] El nombre no se cambió cuando se modificó el algoritmo, ya que es criptográficamente insignificante (ambos forman lo que un criptógrafo reconocería como un nonce de 128 bits), pero el cambio de interfaz podría ser una fuente de confusión para los desarrolladores. Debido al contador de bloques reducido, la longitud máxima del mensaje que se puede cifrar de forma segura con la variante de la IETF es de 2 32 bloques de 64 bytes (256  GiB ). Para aplicaciones donde esto no es suficiente, como el cifrado de archivos o discos, RFC  7539 propone utilizar el algoritmo original con nonce de 64 bits.

El uso de ChaCha20 en IKE e IPsec se ha estandarizado en RFC  7634. ​​La estandarización de su uso en TLS está publicada en RFC  7905.

En 2018, el RFC 7539 quedó obsoleto por el RFC  8439. El RFC 8439 incorpora algunas erratas y agrega consideraciones de seguridad adicionales. [47]

Véase también

Notas

  1. ^ Como la mayor parte del trabajo consiste en realizar rondas repetidas, el número de rondas es inversamente proporcional al rendimiento. Es decir, al reducir a la mitad el número de rondas, el rendimiento se duplica aproximadamente. Las variantes con rondas reducidas son, por lo tanto, apreciablemente más rápidas.

Referencias

  1. ^ por Daniel J. Bernstein (24 de diciembre de 2007). "La familia de cifrados de flujo Salsa20" (PDF) . cr.yp.to .
  2. ^ Daniel J. Bernstein (16 de mayo de 2013). "Salsa 20 velocidad; software Salsa20".
  3. ^ abcd Jean-Philippe Aumasson; Simon Fischer; Shahram Khazaei; Willi Meier; Christian Rechberger (14 de marzo de 2008). "Nuevas características de los bailes latinos" (PDF) . Asociación Internacional para la Investigación Criptológica .
  4. ^ abcd Bernstein, Daniel (28 de enero de 2008), ChaCha, una variante de Salsa20 (PDF) , consultado el 3 de junio de 2018
  5. ^ Daniel J. Bernstein (16 de mayo de 2013). "Snuffle 2005: la función de cifrado de Salsa20".
  6. ^ "Salsa20: Velocidad del software". 11-05-2007.
  7. ^ Daniel J. Bernstein. "Extensión del nonce de Salsa20 (actualizado en 2011)" (PDF) . cr.yp.to . Consultado el 18 de agosto de 2022 .
  8. ^ Daniel J. Bernstein. "Extensión del nonce de Salsa20 (versión original)" (PDF) . cr.yp.to . Consultado el 18 de agosto de 2022 .
  9. ^ "Salsa20/12". ECRYPT II . Consultado el 22 de agosto de 2017 .
  10. ^ "El proyecto eSTREAM: fin de la fase 2". eSTREAM . 2008-04-29.
  11. ^ Hongjun Wu (30 de marzo de 2007). "eSTREAM FASE 3: Fin de la Fase 1". eSTREAM.
  12. ^ "eSTREAM: Breve informe sobre el final de la segunda fase" (PDF) . eSTREAM. 2007-03-26.
  13. ^ "Salsa20/12, la página del portafolio eSTREAM". www.ecrypt.eu.org .
  14. ^ Paul Crowley (9 de febrero de 2006). "Criptoanálisis diferencial truncado de cinco rondas de Salsa20".
  15. ^ Simon Fischer; Willi Meier; Côme Berbain; Jean-François Biasse; MJB Robshaw (2006). "No aleatoriedad en los candidatos de eSTREAM Salsa20 y TSC-4". Progreso en criptología - INDOCRYPT 2006: 7.ª Conferencia internacional sobre criptología en India, Calcuta, India, 11-13 de diciembre de 2006, Actas . Notas de clase en informática. Vol. 4329. págs. 2–16. CiteSeerX 10.1.1.121.7248 . doi :10.1007/11941378_2. ISBN.  978-3-540-49767-7.
  16. ^ Yukiyasu Tsunoo; Teruo Saito; Hiroyasu Kubo; Tomoyasu Suzaki; Hiroki Nakashima (2 de enero de 2007). «Criptoanálisis diferencial de Salsa20/8» (PDF) . ECRIPTA .
  17. ^ Zhenqing Shi; Bin Zhang; Dengguo Feng; Wenling Wu (2012). "Ataques de recuperación de clave mejorados en Salsa20 y ChaCha de ronda reducida". Seguridad de la información y criptología – ICISC 2012. Apuntes de clase en informática. Vol. 7839. págs. 337–351. doi :10.1007/978-3-642-37682-5_24. ISBN 978-3-642-37681-8.
  18. ^ Nicky Mouha; Bart Preneel (2013). "Hacia la búsqueda de características diferenciales óptimas para ARX: aplicación a Salsa20" (PDF) . Asociación Internacional para la Investigación Criptológica .
  19. ^ abc Daniel J. Bernstein (25 de abril de 2008). "La familia ChaCha de cifrados de flujo".
  20. ^ Neves, Samuel (2009-10-07), Implementaciones más rápidas de ChaCha para procesadores Intel, archivado desde el original el 2017-03-28 , recuperado el 2016-09-07 , dos de estas constantes son múltiplos de 8; esto permite una rotación de 1 instrucción en CPU Intel Core2 y posteriores utilizando la instrucción pshufb
  21. ^ Y. Nir; A. Langley (mayo de 2015). "ChaCha20 y Poly1305 para protocolos IETF: RFC 7539".
  22. ^ Arciszewski, Scott (10 de enero de 2020). «XChaCha: eXtended-nonce ChaCha y AEAD_XChaCha20_Poly1305 (borrador de Internet vencido)». Ietf Datatracker .
  23. ^ Aumasson, Jean-Philippe (2020). Demasiadas criptomonedas (PDF) . Simposio sobre criptomonedas en el mundo real.
  24. ^ ab "rand_chacha: considere ChaCha12 (o posiblemente ChaCha8) en lugar de ChaCha20 · Problema n.° 932 · rust-random/rand". GitHub .
  25. ^ "ChaCha". Introducción a la criptografía .
  26. ^ "Haz el ChaCha: mejor rendimiento móvil con criptografía". El blog de Cloudflare . 23 de febrero de 2015. Consultado el 13 de julio de 2021 .
  27. ^ Thomson, Martin; Turner, Sean (mayo de 2021). «RFC 9001». datatracker.ietf.org . Consultado el 13 de julio de 2021 .
  28. ^ Bishop, Mike (2 de febrero de 2021). "borrador: IETF QUIC HTTP". datatracker.ietf.org . Consultado el 13 de julio de 2021 .
  29. ^ Miller, Damien (3 de mayo de 2016). "ssh/PROTOCOL.chacha20poly1305". Referencia cruzada de BSD de superusuario: PROTOCOL.chacha20poly1305 . Consultado el 7 de septiembre de 2016 .
  30. ^ Murenin, Constantine A. (11 de diciembre de 2013). Unknown Lamer (ed.). "OpenSSH tiene un nuevo cifrado —Chacha20-poly1305— de DJ Bernstein". Slashdot . Consultado el 7 de septiembre de 2016 .
  31. ^ Murenin, Constantine A. (30 de abril de 2014). Soulskill (ed.). "OpenSSH ya no tiene que depender de OpenSSL". Slashdot . Consultado el 7 de septiembre de 2016 .
  32. ^ "Revisión 317015". 16 de abril de 2017. Consultado el 16 de marzo de 2018. Reemplazar el algoritmo RC4 para generar números aleatorios seguros en el núcleo con Chacha20
  33. ^ guenther (Philip Guenther), ed. (13 de septiembre de 2015). "libc/crypt/arc4random.c". Referencia cruzada de Super User's BSD: arc4random.c . Consultado el 7 de septiembre de 2016 . Generador de números aleatorios basado en ChaCha para OpenBSD.
  34. ^ riastradh (Taylor Campbell), ed. (25 de marzo de 2016). "libc/gen/arc4random.c". Referencia cruzada de Super User's BSD: arc4random.c . Consultado el 7 de septiembre de 2016 . La API arc4random(3) heredada de OpenBSD se reimplementó utilizando la PRF ChaCha20, con estado por subproceso.
  35. ^ "kern/subr_csprng.c". Referencia cruzada de BSD de superusuario: subr_csprng.c . 2015-11-04 . Consultado el 2016-09-07 .chacha_encrypt_bytes
  36. ^ "Uso y despliegue de ChaCha". 2016-09-07 . Consultado el 2016-09-07 .
  37. ^ "arc4random(3)". Páginas del manual de NetBSD . 2014-11-16. Archivado desde el original el 2020-07-06 . Consultado el 2016-09-07 .
  38. ^ Corbet, Jonathan. "Reemplazar /dev/urandom". Linux Weekly News . Consultado el 20 de septiembre de 2016 .
  39. ^ "Fusionar etiqueta 'random_for_linus' de git.kernel.org/pub/scm/linux/kernel/git/tytso/random". Árbol de fuentes del kernel de Linux . Consultado el 20 de septiembre de 2016. random: reemplazar el pool no bloqueante con un CRNG basado en Chacha20
  40. ^ Michael Larabel (25 de julio de 2016). "/dev/random ve mejoras para Linux 4.8". Phoronix . Consultado el 3 de octubre de 2016 .
  41. ^ Cox, Russ; Valsorda, Filippo. "Aleatoriedad segura en Go 1.22 - El lenguaje de programación Go". go.dev .
  42. ^ "¿Cuál es el atractivo de utilizar ChaCha20 en lugar de AES?". Cryptography Stack Exchange . 12 de abril de 2016.
  43. ^ "Estudio de rendimiento de AES-NI SSL en Calomel.org".
  44. ^ Pfau, Johannes; Reuter, Maximilian; Harbaum, Tanja; Hofmann, Klaus; Becker, Jurgen (septiembre de 2019). "Una perspectiva de hardware sobre los cifrados ChaCha: implementaciones escalables Chacha8/12/20 que van desde 476 porciones hasta tasas de bits de 175 Gbit/s". 2019 32nd IEEE International System-on-Chip Conference (SOCC). págs. 294–299. doi :10.1109/SOCC46988.2019.1570548289. ISBN 978-1-7281-3483-3.
  45. ^ "Protocolo y criptografía". WireGuard . Jason A. Donenfeld . Consultado el 4 de julio de 2018 .
  46. ^ ab "ChaCha20 y Poly1305 para protocolos IETF" (PDF) . Consultado el 7 de agosto de 2017 . Cambios con respecto al ChaCha normal. La división del número de secuencia de bloque nonce se cambió de 64:64 a 96:32 [...] El estado de ChaCha20 se inicializa de la siguiente manera:
  47. ^ Encabezado del RFC 7539.

Enlaces externos