Serpiente (cifrado)

Serpent es un cifrado de bloque de claves simétricas que fue finalista en el concurso Advanced Encryption Standard (AES), donde ocupó el segundo lugar después de Rijndael. Serpent fue diseñado por Ross Anderson, Eli Biham y Lars Knudsen.

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. 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 se puedan ejecutar en paralelo, utilizando sectores 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. El informe oficial del NIST sobre la competencia AES clasificó a Serpent como con un alto margen de seguridad junto con MARS y Twofish, en contraste con el margen de seguridad adecuado de RC6 y Rijndael (actualmente AES). En la votación final, Serpent tuvo la menor cantidad de votos negativos entre los finalistas, pero obtuvo 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.

El algoritmo de cifrado Serpent es de dominio público y no ha sido patentado. El código de referencia es software de dominio público y el código optimizado está bajo GPL. No existen restricciones ni gravámenes de ningún tipo en cuanto a su uso. Como resultado, cualquiera es libre de incorporar Serpent en su software (o implementaciones de hardware) sin pagar tarifas de licencia.

Horario clave

El programa de la llave 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, una "1" El bit se agrega al final de la clave corta seguido de "0" bits hasta que la clave corta se asigne a una longitud de clave larga.

En la siguiente fase, las "preclaves" 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 11 hacia la izquierda. Se agregaron i>FRAC y un índice de ronda para lograr una distribución uniforme de los bits de las claves durante las rondas.

Finalmente las "subclaves" se derivan de las "preclaves" generadas previamente. Esto da como resultado un total de 33 "subclaves" de 128 bits.

At the end the round key or "subkey#34; are placed in the "initial permutation IPc#34; to place the key bits in the correct column.

Pseudocódigo de programación de claves

#define FRAC 0x9e3779b9 // parte fraccional de la relación de oro#define ROTL(A, n) (A Генте n) Silencio (A нелиного (32 - n))uint32_t clave[8] / kuint32_t palabras[132]; //uint32_t subkey[33[ ]4] // sk/* horario clave: obtener prekeys */vacío w()uint32_t *w, uint32_t *k) {} uint32_t imm[140]; para ()corto i = 0; i . 8; i++){ imm[i]=k[i]; }para ()corto i = 8; i . 140; i++) {}imm[i] = ROTL()w[i - 8] ^ w[i - 5] ^ w[i - 3] ^ w[i - 1] ^ FRAC ^ ()i - 8)), 11);w[i-8] = imm[i]}}/* horario clave: conseguir subkeys */vacío k()uint32_t *w, uint32_t ()*sk[4]) {} uint8_t i, p, j, s, k;para ()i = 0; i . 33; i++) {}p = ()32 + 3 - i) % 32;para ()k = 0; k . 32; k++) {}s = S[p % 8[w[4 * i + 0] > k) " 0x1) .. 0 Silencio ()w[4 * i + 1] > k) " 0x1) .. 1 Silencio ()w[4 * i + 2] > k) " 0x1) .. 2 Silencio ()w[4 * i + 3] > k) " 0x1) .. 3 ];para ()j = 0; j . 4; j++) {}sk[i[ ]j] ← ()s > j) " 0x1) .. k;}}}}

Cajas S

Las s-boxes Serpent son permutaciones de 4 bits y están sujetas a las siguientes propiedades:

• una diferencia de entrada de 1 bit nunca conducirá a una diferencia de salida de 1 bit, una característica diferencial tiene una probabilidad de 1:4 o menos.

• las características lineales tienen una probabilidad entre 1:2 y 1:4, la relación lineal entre los bits de entrada y salida tiene una probabilidad entre 1:2 y 1:8.

• el orden no lineal de los bits de salida como función de los bits de entrada es 3. Sin embargo se han encontrado bits de salida que en función de los bits de entrada tienen un orden de sólo 2.

Las s-boxes Serpent 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".

Permutaciones y transformaciones

Permutación inicial (IP)

La permutación inicial funciona con 128 bits a la vez, moviendo bits.

para i dentro 0 .. 127 Swap() bit()i), bit()32 * i) % 127) )

Permutación final (FP)

La permutación final funciona con 128 bits a la vez, moviendo bits.

para i dentro 0 .. 127 Swap() bit()i), bit()2 * i) % 127) )

Transformación lineal (LT)

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 ()corto i = 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[i + 1] = X[i];}

Rijndael contra la serpiente

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 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. Por lo tanto, Rijndael fue elegido ganador del concurso AES.

Serpiente-0 frente a Serpiente-1

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.

Seguridad

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.

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.

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¹¹⁸ textos sin formato conocidos y 2⁸⁹ tiempo y 11 rondas de Serpent-192/256 con 2¹¹⁸ textos planos conocidos y 2¹⁸⁷ tiempo.

Un artículo de 2009 ha notado que el orden no lineal de las Serpent S-boxes no era 3 como afirmaban los diseñadores.

Un ataque de 2011 por Hongjun Wu, Huaxiong Wang y Phuong Ha Nguyen, que también utiliza criptoanálisis lineal, rompe 11 rondas de Serpent-128 con 2¹¹⁶ textos claros conocidos, 2^107,5 tiempo y 2¹⁰⁴ memoria.

El mismo artículo también describe dos ataques que rompen 12 rondas de Serpent-256. El primero requiere 2¹¹⁸ textos planos conocidos, 2^228,8 de tiempo y 2²²⁸ de memoria. El otro ataque requiere 2¹¹⁶ textos planos conocidos y 2¹²¹ memoria, pero también requiere 2^237,5 tiempo.