4.3.2 Fonction $f$

La fonction $f(R_{n-1},K_{n})$ consiste à prendre la partie de droite de l'étape précédente, laquelle est longue de 32 bits, de lui faire subir une fonction d'expansion $E$ (voir tableau 5) jusqu'à 48 bits, et de l'additionner bit par bit avec la clé $K_{n}$ correspondant à l'étape $n$, pour ensuite passer par les S-box qui redonneront une chaîne de 32 bits. Cette chaîne sera finalement permutée selon la permutation $P$. La figure 6 donne un aperçu général de la fonction $f$. Dans ce schéma, $A$ représente $R_{n-1}$ et $J$ représente $K_{n}$.

Figure 6: Schéma général de la fonction $f$

Source: [17], p. 67.

Table 5: Fonction d'expansion $E$

32	1	2	3	4	5
4	5	6	7	8	9
8	9	10	11	12	13
12	13	14	15	16	17
16	17	18	19	20	21
20	21	22	23	24	25
24	25	26	27	28	29
28	29	30	31	32	1

Source: [17], p. 68.

Pour générer les clés propres à chaque étape ($K_{n}$), la clé initiale de 56 bits a dû subir quelques opérations pour devenir une clé de 48 bits. Le processus de création de clés est illustré de façon générale à la figure 7. La première étape consiste à permuter les 56 bits de la clé selon la permutation $\mathrm{PC}1(K)$, illustrée à la table 6. On sépare ensuite la chaîne résultante en deux blocs de 28 bits que l'on note $C_{0}$ et $D_{0}$ de façon à ce que

$$\mathrm{PC}1(K)=C_{0}D_{0}$$

À chaque étape $i$ de 1 à 16, $C_{i}$ et $D_{i}$ sont un décalage de 1 ou 2 positions vers la gauche de $C_{i-1}$ et $D_{i-1}$, respectivement. Aux étapes 1, 2, 9 et 16, on décale de 1 bit, et aux autres étapes on décale de 2 bits.

Figure 7: Processus de création de clés d'étape $K_{n}$

Source: [17], p. 70.

Table 6: Permutation PC1($K$)

57	49	41	33	25	17	9
1	58	50	42	34	26	18
10	2	59	51	43	35	27
19	11	3	60	52	44	36
63	55	47	39	31	23	15
7	62	54	46	38	30	22
14	6	61	53	45	37	29
21	13	5	28	20	12	4

Source: [17], p. 70.

Par la suite, ces 56 bits subissent une deuxième permutation $\mathrm{PC}2(K)$. Cette permutation consiste à abandonner certains bits pour donner une clé $K_{n}$ de 48 bits. Elle est décrite à la table 7.

Table: Permutation $\mathrm{PC}2(K)$

14	17	11	24	1	5
3	28	15	6	21	10
23	19	12	4	26	8
16	7	27	20	13	2
41	52	31	37	47	55
30	40	51	45	33	48
44	49	39	56	34	53
46	42	50	36	29	32

Source: [17], p. 71.

Une fois que la clé $K_{n}$ de 48 bits est générée, il suffit de l'additionner bit-à-bit à $R_{n-1}$ ayant subi une expansion jusqu'à 48 bits. Cette addition binaire est un XOR logique. La fonction XOR prend deux bits en entrée et produit un bit en sortie. Son fonctionnement est décrit au tableau 8. Cette nouvelle chaîne doit alors passer dans les 8 S-box pour donner une chaîne de 32 bits. La chaîne se sépare en 8 parties de 6 bits. Chacune des S-box prend 6 bits en entrée et produit 4 bits en sortie. Les 8 S-box sont illustrées au tableau 9.

Table 8: Fonction XOR

	0	1
0	0	1
1	1	0

Table 9: Les 8 S-box

Supposons que la chaîne de 6 bits est 010101 et qu'elle arrive dans $S_{1}$. On prend le premier et le dernier bit pour obtenir la ligne souhaitée de $S_{1}$. 00 correspond à la première ligne, 01 à la deuxième, 10 à la troisième et 11 à la quatrième. Dans l'exemple, le premier et le dernier bit donnent 01, ce qui correspond à la deuxième ligne. Pour obtenir la colonne, on prend les quatre autre bits, soit 1010, ce qui nous donne 10. À l'intersection de la ligne 2 et de la colonne 11 (les colonnes sont numérotées de 0 à 15), nous trouvons le nombre 12, ce qui produit une sortie binaire de 1100.

Une fois que la fonction $f(R_{n-1},K_{n})$ est complétée, son résultat est XORé avec $L_{n-1}$, ce qui produit $R_{n}$. Après la 16 $^{\mathrm{ième}}$ étape, il y a concaténation des deux blocs d'information $L_{16}$ et $R_{16}$ pour ne former qu'une seule chaîne de 64 bits. Ensuite, ces 64 bits d'information subissent une permutation initiale (voir tableau 4) inversée pour produire la sortie finale.

Pour récupérer le message, faut faire le chemin inverse, c'est-à-dire

$$n = \{16..1\}$$

$$R_{n-1} = L_{n}$$

$$L_{n-1} = R_{n}\bigoplus f(L_{n},K_{n})$$

Nous n'entrerons cependant pas dans les détails du déchiffrement.