Advanced Encryption Standard (AES) - Proceso de cifrado (encrypt)
La información a cifrar - en nuestro caso Mensaje secreto. - se agrupa en bloques de 16 bytes (128 bits) en una matriz de 4 x 4:
| M | a | s | e |
| e | j | e | t |
| n | e | c | o |
| s | r | . |
se traduce
a su código hexadecimal
⇩
La matriz donde ponemos la información a cifrar recibe el nombre de state. Terminado el proceso, el state tendrá el texto cifrado.
1. Primer paso
El primer paso es hacer un XOR (⨁) entre cada célula del state y de la clave (key). Las claves pueden ser de 128, 192 o 256 bits. Usaremos una clave de 128 bits:
State:
⨁
Key0:
=
State luego de XOR con Key0:
XOR (⨁)
A modo de ejemplo de la operación XOR, explicamos el resultado de las primeras células 4d ⨁ 2b = 66:
- Escribimos los números en binario. 4d = 0100 1101 y 2b = 0010 1011.
- El resultado de XOR es 0 si ambos bits son iguales, 1 si son diferentes:
| 0 | 1 | 0 | 0 | 1 | 1 | 0 | 1 | |
| ⨁ | 0 | 0 | 1 | 0 | 1 | 0 | 1 | 1 |
| = | 0 | 1 | 1 | 0 | 0 | 1 | 1 | 0 |
0110 0110 en hexadecimal es 66 que podemos ver en la primera célula de la tercera tabla.
NOTA: Una calculadora científica le permite convertir de decimal a hexadecimal y binario al igual que a realizar operaciones de XOR. Aquí puede leer sobre números binarios, hexadecimales, etc.
2. Próximos pasos
Ahora vamos a hacer 4 operaciones:
- SubBytes
- ShiftRows
- MixColumns
- XOR
Explicamos cada una a continuación.
a. SubBytes
State del paso anterior:
Resultado de SubBytes:
Algoritmo SubBytes
Esta operación sustituye cada uno de los bytes en el state por valores de una tabla llamada Rijndael S-BOX (se genera por un proceso matemático, detalles...). La imagen muestra como buscamos la sustitución para el primer y segundo byte.
Primer byte 66:
- El primer dígito de 66 es 6, lo usamos para buscar en el línea 6.
- El segundo es 6, lo usamos para buscar en el columna 6.
- La célula en la que coincidimos es el valor que buscamos (33).
Segundo byte 1b:
- El primer dígito de 1b es 1, lo usamos para buscar en el línea 1.
- El segundo es b, lo usamos para buscar en el columna b.
- La célula en la que coincidimos es el valor que buscamos (af).
b. ShiftRows
State del paso anterior:
Resultado de ShiftRows:
Algoritmo ShiftRows
- En este paso la primera línea se queda igual.
- En la segunda línea, los bytes 2, 3 y 4 rotan 1 byte a la izquierda. El primer byte pasa a ser el último.
- En la tercera línea, los bytes 3 y 4 rotan 2 bytes a la izquierda. Los primeros 2 bytes pasan a ser los últimos.
- En la cuarta línea, el byte 4 rota 3 bytes a la izquierda. Los primeros 3 bytes pasan a ser los últimos.
Movimientos en cada línea:
c. MixColumns
State del paso anterior:
Resultado de MixColumns:
Algoritmo MixColumns
Este es el paso más complejo. Los bytes de cada columna del state, son modulo multiplicados por una matriz dada usando un método conocido por Rijndael Galois Field. Daremos un ejemplo práctico para explicar el proceso. Recomendamos este video si desea ver la explicación matemática detallada.
Esta imagen ayuda a entender el proceso:
- La tabla State es el state antes de la operación.
- La tabla M es la matriz dada.
Vamos a aplicar el MixColumns a la primera célula del state (33). Para eso debemos multiplicar la columna azul del state por la línea azul de la tabla M y hacer XOR entre los resultados de la siguiente forma:
so = 33 * 2 ⨁ 1c * 3 ⨁ 38 * 1 ⨁ c9 * 1
Las multiplicaciones son algo especial. Usaremos tablas con los resultados calculados previamente (vea este video para detalles).
Multiplicación 33 * 2:
Esta es la tabla para mutiplicar por 2. Buscamos el resultado de forma igual a como buscamos en la tabla S-BOX:
33 * 2 = 66
Multiplicación 1c * 3:
Esta es la tabla para multiplicar por 3:
1c * 3 = 24
La multiplicación por 1 no altera el valor, por lo que podemos ir al último paso:
66 ⨁ 24 ⨁ 38 ⨁ c9 = b3
b3 es el nuevo valor de la célula 0.
Cálculo de las demás células
Las demás células se calculan de la misma forma, pero cada una usa líneas y columnas diferentes:
| célula | columna (state) | línea (matriz) | célula | columna (state) | línea (matriz) | célula | columna (state) | línea (matriz) | célula | columna (state) | línea (matriz) |
|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | azul | azul | 4 | verde | azul | 8 | amarilla | azul | 12 | blanca | azul |
| 1 | azul | verde | 5 | verde | verde | 9 | amarilla | verde | 13 | blanca | verde |
| 2 | azul | amarilla | 6 | verde | amarilla | 10 | amarilla | amarilla | 14 | blanca | amarilla |
| 3 | azul | blanca | 7 | verde | blanca | 11 | amarilla | blanca | 15 | blanca | blanca |
d. XOR con Key1
Resultado de MixColumns
⨁
Key1
=
XOR:
Este XOR se hace con una segunda clave (Key1) derivada de la clave original (explicamos el proceso de generación de claves más adelante). En total, generaremos 10 claves partiendo de la clave original.
3. Las vueltas...
Ahora, repetimos 9 veces los procesos ya explicados, siguiendo este orden: SubBytes, ShiftRows, MixColumns y XOR. Cada vuelta usa una clave diferente.
Resultados después de cada operación en vuelta 2
SubBytes:
ShiftRows:
MixColumns:
⨁
Key2
=
XOR:
Resultados después de cada operación en vuelta 3
SubBytes:
ShiftRows:
MixColumns:
⨁
Key3
=
XOR:
Resultados después de cada operación en vuelta 4
SubBytes:
ShiftRows:
MixColumns:
⨁
Key4
=
XOR:
Resultados después de cada operación en vuelta 5
SubBytes:
ShiftRows:
MixColumns:
⨁
Key5
=
XOR:
Resultados después de cada operación en vuelta 6
SubBytes:
ShiftRows:
MixColumns:
⨁
Key6
=
XOR:
Resultados después de cada operación en vuelta 7
SubBytes:
ShiftRows:
MixColumns:
⨁
Key7
=
XOR:
Resultados después de cada operación en vuelta 8
SubBytes:
ShiftRows:
MixColumns:
⨁
Key8
=
XOR:
Resultados después de cada operación en vuelta 9
SubBytes:
ShiftRows:
MixColumns:
⨁
Key9
=
XOR:
4. Últimos pasos
Resultados después de cada operación y texto cifrado
La vuelta final no hace el MixColumns. Por lo demás es igual a las anteriores.
SubBytes:
ShiftRows:
MixColumns:
No se usa MixColumns
en la última vuelta
⨁
Key10
=
Finalmente llegamos al texto cifrado tras el último XOR:
Generación de claves
Necesitamos 10 claves adicionales a la original. Se generan siguiendo este proceso:
Primeros 4 bytes de la nueva clave (bytes 0 - 3)
Para generar los primeros 4 bytes de la nueva clave key 1 (vea la imagen que sigue):
- La clave original (key0 aparece en el número 1).
- Reorganizamos los últimos 4 bytes de la clave.
- Sustituimos cada byte usando la tabla S-BOX.
- Hacemos un XOR con los 4 bytes de rcon1 (explicación más adelante).
- Resultado del XOR anterior.
- Hacemos otro XOR con los primeros 4 bytes de la clave original.
- Finalmente, tenemos los primeros 4 bytes de la nueva clave (key 1).
Bytes 4 a 15
Las próximos bytes se generan de manera mucho más sencilla (ver imagen a continuación):
- Bytes 4 a 7 (2da columna): XOR entre los bytes 4 a 7 de la clave original y los 4 bytes anteriores de la nueva clave (en rojo).
- Bytes 8 a 11 (3ra columna): XOR entre los bytes 8 a 11 de la clave original y los 4 bytes anteriores de la nueva clave (en azul).
- Bytes 12 a 15 (4ta columna): XOR entre los bytes 12 a 15 de la clave original y los 4 bytes anteriores de la nueva clave (en verde).
Claves key2 a key10
Necesitamos 10 claves adicionales a la original:
- Para generar las demás claves partimos siempre de la clave anterior (key2 se genera partiendo de key1).
- Los valores de rcon cambian para cada clave (rcon2 para generar key2, rcon3 para key3, etc.). Pueden ver los valores de rcon (hexadecimales) en la imagen anterior.