M8 (cifrado)

Cifrado de bloque

En criptografía , M8 es un algoritmo de cifrado por bloques diseñado por Hitachi en 1999. Es una modificación del algoritmo M6 de Hitachi , diseñado para lograr una mayor seguridad y un alto rendimiento tanto en implementaciones de hardware como de software de 32 bits. M8 fue registrado por Hitachi en marzo de 1999 como ISO/IEC 9979-0020. ^[1]

Al igual que M6, M8 es un cifrado de Feistel con un tamaño de bloque de 64 bits. La función round puede incluir rotaciones de 32 bits , operaciones XOR y suma modular , lo que lo convierte en un ejemplo temprano de un cifrado ARX .

El cifrado incluye una cantidad variable de rondas (cualquier número entero positivo N), cada una de las cuales tiene una estructura determinada por una " clave de decisión algorítmica " específica de cada ronda. Hacer que las rondas dependan de la clave tiene como objetivo dificultar el criptoanálisis (consulte FROG para obtener una filosofía de diseño similar).

Descripción del cifrado

El recuento de redondeos se puede establecer en cualquier entero positivo N, pero se recomienda un recuento de redondeos de al menos 10. La clave consta de cuatro componentes: una clave de datos de 64 bits, una clave de expansión de clave de 256 bits, un conjunto de N claves de decisión de algoritmo de 24 bits y un conjunto de N claves de expansión de algoritmo de 96 bits.

La función de redondeo se utiliza tanto para la expansión de claves como para el cifrado/descifrado. El proceso de expansión de claves transforma la clave de datos de 64 bits y la clave de expansión de claves de 256 bits en una clave de ejecución de 256 bits, que consta de 4 pares de números de 32 bits . ${\displaystyle K_{R_{0}},K_{L_{0}},...,K_{R_{3}},K_{L_{3}}}$

El cifrado tiene un diseño típico de cifrado Feistel . Primero, el bloque de entrada de 64 bits se divide en dos mitades de 32 bits. En cada ronda, la mitad izquierda sufre una transformación dependiente de la clave y luego se combina con la mitad derecha. Finalmente, las mitades se intercambian. En total, la función de ronda consta de una secuencia de nueve operaciones personalizables y tres rotaciones bit a bit:

${\displaystyle {\begin{aligned}R_{i+1}&=L_{i}\\x&=L_{i}\operatorname {op} _{1}K_{L_{i{\bmod {4}}}}\\y&=((x<<<S_{1})\operatorname {op} _{2}x)\operatorname {op} _{3}\alpha \\z&=(((y<<<S_{2})\operatorname {op} _{4}y)\operatorname {op} _{5}\beta )\operatorname {op} _{6}K_{R_{i{\bmod {4}}}}\\L_{i+1}&=(((z<<<S_{3})\operatorname {op} _{7}z)\operatorname {op} _{8}\gamma )\operatorname {op} _{9}R_{i}\end{aligned}}}$

${\displaystyle i}$denota el número redondo, que toma entradas y . son las tres palabras de 32 bits de la clave de expansión del algoritmo de la ronda. son palabras de la clave de ejecución. denota una rotación bit a bit a la izquierda. y se definen mediante la clave de decisión del algoritmo de 24 bits de la siguiente manera: ${\displaystyle L_{i}}$ ${\displaystyle R_{i}}$ ${\displaystyle \alpha ,\beta ,\gamma }$ ${\displaystyle K_{R_{i{\bmod {4}}}},K_{L_{i{\bmod {4}}}}}$ ${\displaystyle <<<}$ ${\displaystyle \operatorname {op} _{j}}$ ${\displaystyle S_{k}}$

Número de serie más alto (MSB) Número de serie más bajo (LSB)op1 op2 op3 op4 op5 op6 op7 op8 op9 S1 S2 S3

donde op1 a op9 son cada uno un bit (0 = suma módulo 2 ³² , 1 = XOR) y S1 a S3 son cinco bits cada uno.

La expansión de claves consta de ocho rondas de cifrado, utilizando las primeras ocho claves de decisión y expansión de algoritmos, la clave de expansión de claves como clave de ejecución y la clave de datos como bloque de entrada. Las ocho salidas intermedias se utilizan como los ocho componentes de la clave de ejecución . ${\displaystyle L_{1},L_{2},...,L_{7},L_{8}}$ ${\displaystyle K_{R_{0}},K_{L_{0}},...,K_{R_{3}},K_{L_{3}}}$

Implementación de cifrado

La siguiente es una implementación del cifrado en Python .

# https://en.wikipedia.org/wiki/M8_(cipher)/M8_(cifrado)M  =  0xffffffffdef  add ( x ,  y ):  devuelve  ( x  +  y )  &  Mdef  xor ( x ,  y ):  devuelve  x  ^  ydef  rol ( x ,  s ):  return  (( x  <<  s )  |  ( x  >>  ( 32  -  s )))  &  Mdef  m8_round ( L ,  R ,  ri ,  k ,  adk ,  aek ): """  Una ronda del algoritmo.  L, R: entrada  ri: índice redondo  k: clave de ejecución de 256 bits  adk: clave de decisión de algoritmo de 24 bits  aek: clave de expansión de algoritmo de 96 bits  """ op  =  [[ add ,  xor ][( adk  >>  ( 23  -  i ))  &  1 ]  para  i  en  el rango ( 9 )]  S1  =  ( adk  >>  10 )  &  0x1f  S2  =  ( adk  >>  5 )  &  0x1f  S3  =  ( adk  >>  0 )  &  0x1f  A  =  ( aek  >>  64 )  &  M  B  =  ( aek  >>  32 )  &  M  C  =  ( aek  >>  0 )  &  M  KR  =  ( k  >>  ( 32  +  64  *  ( 3  -  ri  %  4 )))  &  M  KL  =  ( k  >>  ( 0  +  64  *  ( 3  -  ri  %  4 )))  &  M x  =  op [ 0 ]( L ,  KL )  y  =  op [ 2 ]( op [ 1 ]( rol ( x ,  S1 ),  x ),  A )  z  =  op [ 5 ]( op [ 4 ]( op [ 3 ]( rol ( y ,  S2 ),  y ),  B ),  KR )  return  op [ 8 ]( op [ 7 ]( op [ 6 ]( rol ( z ,  S3 ),  z ),  C ),  R ),  Ldef  m8_keyexpand ( dk ,  kek ,  adks ,  aeks ): """  Expansión de clave.  dk: clave de datos de 64 bits  kek: clave de expansión de clave de 256 bits  adks: claves de decisión de algoritmo  aeks: claves de expansión de algoritmo  """ L  =  ( dk  >>  32 )  y  M  R  =  ( dk  >>  0 )  y  M  k  =  0  para  i  en  el rango ( 8 ):  L ,  R  =  m8_round ( L ,  R ,  i ,  kek ,  adks [ i ],  aeks [ i ])  k  |=  ( L  <<  ( 32  *  ( 7  -  i )))  devuelve  kdef  m8_encrypt ( data ,  N ,  dk ,  kek ,  adks ,  aeks ): """  Cifrar un bloque con M8.  datos: bloque de entrada de 64 bits  N: número de rondas (debe ser >= 8)  dk: clave de datos de 64 bits  kek: clave de expansión de clave de 256 bits  adks: una lista de N claves de decisión de algoritmo de 24 bits  aeks: una lista de N claves de expansión de algoritmo de 96 bits  """ ek  =  m8_keyexpand ( dk ,  kek ,  adks ,  aeks )  L  =  ( datos  >>  32 )  &  M  R  =  ( datos  >>  0 )  &  M  para  i  en  el rango ( N ):  L ,  R  =  m8_round ( L ,  R ,  i ,  ek ,  adks [ i ],  aeks [ i ])  return  ( L  <<  32 )  |  R# Vector de prueba publicado de ISO/IEC 9979/0020 result  =  m8_encrypt (  0x0000_0000_0000_0001 ,  126 ,  0x0123_4567_89AB_CDEF ,  0 ,  [ 0x848B6D ,  0x8489BB ,  0x84B762 ,  0x84EDA2 ]  *  32 ,  [ 0x0000_0001_0000_0000_0000_0000 ]  *  126 , ) assert  result  ==  0xFE4B_1622_E446_36C0

Vectores de prueba

La versión publicada de ISO/IEC 9979-0020 incluye los siguientes datos de prueba:

• Número redondo: 126
• Clave de expansión de clave: 0 ²⁵⁶ (un vector de todos ceros)
• Clave de datos: 0123 4567 89AB CDEF en hexadecimal
• Clave de decisión del algoritmo:
  • rondas 1, 5, 9, ...: 848B6D hex
  • rondas 2, 6, 10, ...: 8489BB hex
  • rondas 3, 7, 11, ...: 84B762 hex
  • rondas 4, 8, 12, ...: 84EDA2 hex
• Clave de expansión del algoritmo: 0000 0001 0000 0000 0000 0000 hexadecimal para todas las rondas

• Texto sin formato: 0000 0000 0000 0001 hexadecimal
• Texto cifrado después de 7 rondas: C5D6 FBAD 76AB A53B hex
• Texto cifrado después de 14 rondas: 6380 4805 68DB 1895 hex
• Texto cifrado después de 21 rondas: 2BFB 806E 1292 5B18 hex
• Texto cifrado después de 28 rondas: F610 6A41 88C5 8747 hex
• Texto cifrado después de 56 rondas: D3E1 66E9 C50A 10A2 hex
• Texto cifrado final después de 126 rondas: FE4B 1622 E446 36C0 hex

Criptoanálisis

El comportamiento dependiente de la clave del cifrado da como resultado una gran clase de claves débiles que exponen el cifrado a una variedad de ataques, incluido el criptoanálisis diferencial , el criptoanálisis lineal y el criptoanálisis mod n . ^[2]

Referencias

1. "Entrada de registro ISO/IEC9979-0020" (PDF) . Profesor Chris Mitchell, Grupo de Seguridad de la Información, Royal Holloway, Universidad de Londres . Registro ISO/IEC 9979 de algoritmos criptográficos.
2. Toshio Tokita; Tsutomu Matsumoto. "Sobre la aplicabilidad del criptoanálisis diferencial, el criptoanálisis lineal y el criptoanálisis Mod n a un algoritmo de cifrado M8 (ISO9979-20)". Ipsj Journal . 42 (8).