AES demonstration tool

Principe de "Key Schedule"

Les clés de l'AES font 128,192 ou 256 bits. Chacune correspondant à un nombre de répétition du chiffrement.
Or pour éviter certaines attaques issues de la cryptanalyse, ces clés sont étendues.
Cela veut simplement signifier que d'autres clés sont créées à partir de la clé initiale.
Ainsi le Key schedule va permettre de créer une clé différente par tour de chiffrement, chacune de ces clés sous-clé faisant 128 bits.
On peut donc se demander deux choses :

Pourquoi n'utilise t-on pas alors que des clés de 128 bits ? (Pourquoi en utiliser 256 si c'est pour retomber à 128 ?)
Pourquoi n'utilise t'on pas une clé qui serait de la taille du bloc de donnée multipliée par le nombre de tours ?

Les clés de 128 bits sont plus faibles que celles de 192, qui sont elles-même plus faibles que celle de 256 bits.
Cela est justement dû au Key schedule, il permet de contrer certaines attaques, et sa construction implique qu'une clé de plus grande taille est plus sûre.
Ensuite, une seule grande clé serait aussi dangereux.
Tout d'abord à retenir. Il y aurait le risque que les gens choississent une clé facile à retenir, et donc plus facile à trouver.
Et finalement L'utilisation d'une seule grande clé est en fait ce que fait l'AES via le Key Schedule.
Cela permet d'avoir une clé complexe lors du chiffrement, mais suffisamment courte initialement pour être retenue.

Algorithme de Key Schedule

Nous allons nous concentrer ici sur le Key Schedule des clés de 128 bits. Il n'y a qu'une légère altération pour les clés de plus grandes tailles.
Les clés faisant 128 bits, cela correspond à 16 octets. Par la suite, ils seront compactés par groupe de 4, tel que : $\begin{array}{cccl} S o i t K & \Leftrightarrow & b_{0} b_{1} \dots b_{126} b_{127} & A v e c b_{i} \in \{0; 1\} \\ \Leftrightarrow & V_{0} V_{1} \dots V_{14} V_{15} & A v e c V_{i} = \{b_{8 i} b_{8 i + 1} b_{8 i + 2} b_{8 i + 3} b_{8 i + 4} b_{8 i + 5} b_{8 i + 6} b_{8 i + 7}\} \\ \Leftrightarrow & W_{0} W_{1} W_{2} W_{3} & A v e c W_{i} = {V_{4 i} V_{4 i + 1} V_{4 i + 2} V_{4 i + 3}} \end{array}$
Dans le cas d'une clé de 128 bits, il y a 10 répétitions de l'algorithme. Il faut donc générer 10 clés supplémentaires (une clé étant utilisée avant le début des répétitions).
Le Key schedule se répète à chaque nouvelle clé. Ainsi la i^éme clé est calculée à partir de la clé i+1.
on a : $k e y S c h e d u l e (K_{i}) = K_{i + 1}$

L'opération d'extension de la clé consiste donc à produire 128 bits. On a ainsi le format suivant :
$\{\begin{array}{clc} W_{4} = & W_{0} + g (W_{3}) & A v e c g () f o n c t i o n n o n l i n é a i r e \\ W_{5} = & W_{4} + W_{1} \\ W_{6} = & W_{5} + W_{2} \\ W_{7} = & W_{6} + W_{3} \end{array}$

Le système ici est assez simple et se répétera à chaque itération de Key Schedule. (Pour la répétition suivante, W4 devient W0 et ainsi de de suite).
La somme se fait selon le schéma habituel, il s'agit d'une opération XOR (bit à bit) sur les deux blocs de 128 bits (somme dans GF(2)).
Le point important ici est la fonction g(). Elle s'applique donc sur un bloc de 4 octets et se décompose en 3 étapes
ici $g_{1}, g_{2}, g_{3}$ représente les 3 étapes de la fonction g() :

un décalage (similaire à un ShiftColumn) de 3 :
$g_{1} (W_{3}) = g_{1} (V_{12} V_{13} V_{14} V_{15}) = V_{13} V_{14} V_{15} V_{12}$

On applique ensuite à chaque octet la transformation SubByte :
$g_{2} (V_{13} V_{14} V_{15} V_{12}) = S (V_{13}) S (V_{14}) S (V_{15}) S (V_{12}) = V_{13}^{'} V_{14}^{'} V_{15}^{'} V_{12}^{'}$

On somme sur le premier octet un coefficient (puissance de 2 dans GF(2⁸) qui va dépendre de l'indice j de la répétition.
$\begin{aligned} g_{3} (V_{13}^{'} V_{14}^{'} V_{15}^{'} V_{12}^{'}) = & V_{13}^{'} + R^{j - 1} V_{14}^{'} V_{15}^{'} V_{12}^{'} \\ A v e c R = & 0 * X^{7} + 0 * X^{6} + 0 * X^{5} + 0 * X^{4} + 0 * X^{3} + 0 * X^{2} + 1 * X^{1} + 0 * X^{0} \end{aligned}$

Comme nous sommes toujours dans GF(2⁸), les puissances de ce polynôme sont restreintes par le polynôme caractéristique de l'AES, P (voir section Maths).
Ainsi on a :

\begin{matrix} i n d i c e d e l a r é p é t i t i o n & j = 1; & R^{0} m o d P = & (00000001)_{2} \\ j = 2; & R^{1} m o d P = & (00000010)_{2} \\ j = 3; & R^{2} m o d P = & (00000100)_{2} \\ ⋮ & ⋮ & ⋮ \\ j = 4; & R^{9} m o d P = & (00110110)_{2} \end{matrix}

Pour résumer on a donc les 128 bits qui sont réunis par groupe de 4 octets, le premier est sommé avec le troisième, modifié par g().
Tout les autres sont ensuite sommés avec l'élément précédent et l'élément équivalent dans la clé précédente.
Cela donne le schéma suivant : algorithm

Clés de 192 bits

le schéma pour la création des sous-clés de 192 bits est presque similaire :
algorithm
Il y a cependant un élément à prendre en compte, il y a besoin d'aller jusqu'a $W_{51}$ . Or, on créé a chaque fois 6 nouveaux éléments $(W_{5} \to W_{11})$ .
On arrive donc à $W_{47}$ , il ne faut donc que 4 élements supplémentaires $(W_{48} \to W_{51})$ .
Pour la fonction g(), il s'agit toujours du dernier élement de la ligne précédente (le 6^ème parmis 6).
(Il serait possible de créer encore 6 éléments, mais 2 ne seraient jamais utilisés.)

Clés de 256 bits

le schéma pour la création des sous-clés de 256 bits est presque similaire :
algorithm
De même que pour les clés de 192 bits, lors de la dernière itération il n'est nécessaire de créer que 4 éléments $(W_{56} \to W_{59})$ .
On peut voir un ajout ici, il s'agit de la deuxième étape de la fonction g(), l'opération SubByte.

Réversibilité

L'AES étant symétrique, la même clé est utilisée pour le déchiffrement. Les mêmes Round Key (clé par itération) sont donc utilisées.
La différence va résider dans la création des clés, en effet, il y a deux manières de faire :

Toutes les créer avant le chiffrement, ce qui peut prendre du temps (selon la taille de la clé)
Les créer au fur et à mesure des itérations

Or, dans le cas du déchiffrement, on commence par utiliser la clé de la derniére itération.
En effet, on déchiffre dans l'ordre des couches, or la dernière itération utilisant la dernière clé, on est obligé de créer toutes les clés avant de pouvoir déchiffrer.