Serpent es un cifrado de bloque de clave simétrica que quedó finalista en el concurso Advanced Encryption Standard (AES) , en el que ocupó el segundo lugar detrás de Rijndael . [2] Serpent fue diseñado por Ross Anderson , Eli Biham y Lars Knudsen . [3]
Al igual que otros envíos de AES , Serpent tiene un tamaño de bloque de 128 bits y admite un tamaño de clave de 128, 192 o 256 bits. [4] El cifrado es una red de sustitución-permutación de 32 rondas que opera en un bloque de cuatro palabras de 32 bits . Cada ronda aplica una de las ocho cajas S de 4 bits a 4 bits 32 veces en paralelo. Serpent fue diseñado para que todas las operaciones puedan ejecutarse en paralelo , utilizando segmentos de 32 bits . Esto maximiza el paralelismo pero también permite el uso del extenso trabajo de criptoanálisis realizado en DES .
Serpent adoptó un enfoque conservador en materia de seguridad, optando por un gran margen de seguridad: los diseñadores consideraron que 16 rondas eran suficientes contra tipos de ataques conocidos, pero especificaron 32 rondas como seguro contra futuros descubrimientos en criptoanálisis. [5] El informe oficial del NIST sobre la competencia AES clasificó a Serpent como con un alto margen de seguridad como MARS y Twofish y en contraste con el margen de seguridad adecuado de RC6 y Rijndael (actualmente AES). [2] En la votación final, Serpent tuvo la menor cantidad de votos negativos entre los finalistas, pero ocupó el segundo lugar en general porque Rijndael tuvo sustancialmente más votos positivos, siendo el factor decisivo que Rijndael permitió una implementación de software mucho más eficiente. [ cita necesaria ]
El algoritmo de cifrado Serpent es de dominio público y no ha sido patentado . [6] El código de referencia es software de dominio público y el código optimizado tiene licencia GPL . [7] No existen restricciones ni gravámenes respecto de su uso. Como resultado, cualquiera es libre de incorporar Serpent en su software (o en implementaciones de hardware) sin pagar tarifas de licencia.
El programa clave de la Serpiente consta de 3 etapas principales. En la primera etapa, la clave se inicializa agregando relleno si es necesario. Esto se hace para hacer que las claves cortas se asigne a claves largas de 256 bits, se agrega un bit "1" al final de la clave corta seguido de bits "0" hasta que la clave corta se asigne a una longitud de clave larga. [4]
En la siguiente fase, las "claves previas" se derivan utilizando la clave previamente inicializada. Las partes clave de 32 bits se XOR, el FRAC que es la fracción de la proporción áurea y el índice redondo se XOR con las partes clave, el resultado de la operación XOR se gira hacia la izquierda en 11. El FRAC y el índice redondo se agregaron para lograr una distribución uniforme de los bits claves durante las rondas. [4]
Finalmente las "subclaves" se derivan de las "preclaves" generadas previamente. Esto da como resultado un total de 33 "subclaves" de 128 bits. [4]
Al final se coloca la clave redonda o "subclave" en la "IP de permutación inicial" para colocar los bits de la clave en la columna correcta. [4]
#define FRAC 0x9e3779b9 // parte fraccionaria de la proporción áurea #define ROTL(A, n) ((A) << n | (A) >> 32-n)tecla uint32_t [ 8 ]; // clave proporcionada por el usuario uint32_t subclave [ 33 ][ 4 ]; // claves redondas const uint8_t S [ 8 ][ 16 ] = {}; // cajas S /* programación de claves: obtener claves previas */ void get_pre ( uint32_t w [ 4 * 33 ], const uint32_t k [ 8 ]) { uint32_t x [ 4 * 33 + 8 ]; para ( int i = 0 ; i < 8 ; i ++ ) x [ i ] = k [ i ]; for ( int i = 8 ; i < 140 ; i ++ ) { x [ i ] = ROTL ( x [ i -8 ] ^ x [ i -5 ] ^ x [ i -3 ] ^ x [ i -1 ] ^ FRAC ^ ( i -8 ), 11 ); w [ yo -8 ] = x [ yo ]; } } /* programación de claves: obtener subclaves */ void get_sk ( const uint32_t w [ 4 * 33 ], uint32_t ( * sk )[ 4 ]) { uint8_ti , p , j , s , k ; para ( yo = 0 ; yo < 33 ; yo ++ ) { p = 32 + 3 - yo ; para ( j = 0 ; j < 4 ; j ++ ) sk [ i ] [ j ] = 0 ; para ( k = 0 ; k < 32 ; k ++ ) { s = S [ p % 8 ][(( w [ 4 * i + 0 ] >> k ) & 0x1 ) << 0 | (( w [ 4 * i + 1 ] >> k ) & 0x1 ) << 1 | (( w [ 4 * i + 2 ] >> k ) & 0x1 ) << 2 | (( w [ 4 * i + 3 ] >> k ) & 0x1 ) << 3 ]; for ( j = 0 ; j < 4 ; j ++ ) { sk [ i ][ j ] |= (( s >> j ) & 0x1 ) << k ; } } } } void key_schedule () { uint32_t w [ 4 * 33 ]; get_pre ( w , clave ); get_sk ( w , subclave ); } Las Serpent s-boxes son permutaciones de 4 bits y están sujetas a las siguientes propiedades:
Las Serpent s-boxes se han construido basándose en las 32 filas de las s-boxes DES . Estos se transformaron intercambiando entradas, las matrices resultantes con las propiedades deseadas se almacenaron como Serpent s-boxes. Este proceso se repitió hasta que se encontraron un total de 8 s-boxes. En este proceso se utilizó la siguiente clave: "sboxesforserpent". [4]
La permutación inicial funciona con 128 bits a la vez, moviendo bits.
para i en 0 .. 127 intercambio ( bit ( i ), bit (( 32 * i ) % 127 ) ) La permutación final funciona con 128 bits a la vez, moviendo bits.
para i en 0 .. 127 intercambio ( bit ( i ), bit (( 4 * i ) % 127 ) ) Consta de operaciones XOR, S-Box, desplazamiento de bits a la izquierda y rotación de bits a la izquierda. Estas operaciones se realizan en 4 palabras de 32 bits.
para ( i corto = 0 ; i < 4 ; i ++ ) { X [ i ] = S [ i ][ B [ i ] ^ K [ i ]]; } X [ 0 ] = ROTL ( X [ 0 ], 13 ); X [ 2 ] = ROTL ( X [ 2 ], 3 ); X [ 1 ] = X [ 1 ] ^ X [ 0 ] ^ X [ 2 ]; X [ 3 ] = X [ 3 ] ^ X [ 2 ] ^ ( X [ 0 ] << 3 ); X [ 1 ] = ROTL ( X [ 1 ], 1 ); X [ 3 ] = ROTL ( X [ 3 ], 7 ); X [ 0 ] = X [ 0 ] ^ X [ 1 ] ^ X [ 3 ]; X [ 2 ] = X [ 2 ] ^ X [ 3 ] ^ ( X [ 1 ] << 7 ); X [ 0 ] = ROTL ( X [ 0 ], 5 ); X [ 2 ] = ROTL ( X [ 2 ], 22 ); para ( corto i = 0 ; i < 4 ; i ++ ) { B [ yo + 1 ] = X [ yo ]; } Rijndael es una red de transformación lineal de sustitución con diez, doce o catorce rondas, según el tamaño de la clave, y con tamaños de clave de 128 bits, 192 bits o 256 bits, especificados de forma independiente. Serpent es una red de sustitución-permutación que tiene treinta y dos rondas, más una permutación inicial y una final para simplificar una implementación optimizada. La función redonda en Rijndael consta de tres partes: una capa no lineal, una capa de mezcla lineal y una capa XOR de mezcla de claves. La función de ronda en Serpent consiste en XOR de combinación de claves, treinta y dos aplicaciones paralelas de la misma caja S 4 × 4 y una transformación lineal, excepto en la última ronda, donde otra XOR de combinación de claves reemplaza la transformación lineal. La capa no lineal en Rijndael usa una caja S de 8 × 8, mientras que Serpent usa ocho cajas S de 4 × 4 diferentes. Las 32 rondas significan que Serpent tiene un margen de seguridad mayor que Rijndael; sin embargo, Rijndael con 10 rondas es más rápido y más fácil de implementar para bloques pequeños. [9] Por lo tanto, Rijndael fue seleccionado como el ganador en el concurso AES.
El Serpent original, Serpent-0, se presentó en el quinto taller sobre cifrado rápido de software , pero se presentó una versión algo modificada, Serpent-1, a la competencia AES. El documento de presentación de AES analiza los cambios, que incluyen diferencias clave en la programación.
El ataque XSL , si es efectivo, debilitaría a Serpent (aunque no tanto como debilitaría a Rijndael , que se convirtió en AES ). Sin embargo, muchos criptoanalistas creen que una vez que se tienen en cuenta las consideraciones de implementación, el ataque XSL sería más costoso que un ataque de fuerza bruta . [ cita necesaria ]
En 2000, un artículo de Kohno et al. presenta un ataque de encuentro en el medio contra 6 de 32 rondas de Serpent y un ataque de boomerang amplificado contra 9 de 32 rondas de Serpent. [10]
Un ataque de 2001 realizado por Eli Biham , Orr Dunkelman y Nathan Keller presenta un ataque de criptoanálisis lineal que rompe 10 de 32 rondas de Serpent-128 con 2 118 textos claros conocidos y 2 89 de tiempo, y 11 rondas de Serpent-192/256 con 2 118 conocidos. textos claros y 2 187 tiempo. [11]
Un artículo de 2009 notó que el orden no lineal de las Serpent S-boxes no era 3 como afirmaban los diseñadores. Específicamente, cuatro elementos tenían orden 2. [8]
Un ataque de 2011 realizado por Hongjun Wu, Huaxiong Wang y Phuong Ha Nguyen, que también utilizó criptoanálisis lineal, rompe 11 rondas de Serpent-128 con 2.116 textos claros conocidos, 2.107,5 de tiempo y 2.104 de memoria. [1]
El mismo artículo también describe dos ataques que rompen 12 rondas de Serpent-256. El primero requiere 2.118 textos claros conocidos, 2.228,8 de tiempo y 2.228 de memoria. El otro ataque requiere 2.116 textos planos conocidos y 2.121 de memoria, pero también requiere 2.237,5 de tiempo.
{{cite journal}}: Citar diario requiere |journal=( ayuda ){{cite journal}}: Citar diario requiere |journal=( ayuda ){{cite journal}}: Citar diario requiere |journal=( ayuda ){{cite journal}}: Citar diario requiere |journal=( ayuda )