# TD2 — AES en pratique — Réponses complètes

---

## Exercices sur papier

---

### Exercice 1 — Conversions décimal / hexadécimal

#### Sous-partie A — Conversions

| Décimal | Hex |
|---------|-----|
| 65      | 41  |
| 200     | C8  |
| 255     | FF  |
| 16      | 10  |

| Hex | Décimal |
|-----|---------|
| 4A  | 74      |
| FF  | 255     |
| 1F  | 31      |
| B0  | 176     |

#### Sous-partie B — Encodage ASCII

| Mot     | Hex                          |
|---------|------------------------------|
| AES     | 41 45 53                     |
| Crypto  | 43 72 79 70 74 6F            |
| Hello!  | 48 65 6C 6C 6F 21            |

#### Sous-partie C — XOR sur octets

| Opération   | Résultat | Détail                                              |
|-------------|----------|-----------------------------------------------------|
| FF ⊕ 0F     | F0       | 1111 1111 ⊕ 0000 1111 = 1111 0000                   |
| A5 ⊕ A5     | 00       | Tout octet XORé avec lui-même vaut 0                |
| 41 ⊕ 20     | 61       | 'A' (0x41) XOR espace (0x20) = 'a' (0x61) — bascule majuscule/minuscule |
| 42 ⊕ 0F     | 4D       |                                                     |

'A' XOR espace donne 'a' : le XOR avec 0x20 bascule le bit 5, ce qui convertit une lettre majuscule en minuscule (et vice-versa) en ASCII.

---

### Exercice 2 — Un round AES à la main sur "BONJOUR LES AMIS"

#### Question 1 — Matrice d'état initiale (column-major)

Encodage ASCII de `BONJOUR LES AMIS` :
`42 4F 4E 4A 4F 55 52 20 4C 45 53 20 41 4D 49 53`

| col 0 | col 1 | col 2 | col 3 |
|-------|-------|-------|-------|
| 42    | 4F    | 4C    | 41    |
| 4F    | 55    | 45    | 4D    |
| 4E    | 52    | 53    | 49    |
| 4A    | 20    | 20    | 53    |

#### Question 2 — Après AddRoundKey (XOR 0F partout)

| col 0 | col 1 | col 2 | col 3 |
|-------|-------|-------|-------|
| 4D    | 40    | 43    | 4E    |
| 40    | 5A    | 4A    | 42    |
| 41    | 5D    | 5C    | 46    |
| 45    | 2F    | 2F    | 5C    |

Exemple : 42 ⊕ 0F = 4D ; 4F ⊕ 0F = 40, etc.

#### Question 3 — Après SubBytes (S-Box AES)

Substitution de chaque octet via la S-Box AES (ligne = quartet haut, colonne = quartet bas) :

| col 0 | col 1 | col 2 | col 3 |
|-------|-------|-------|-------|
| E3    | 09    | 1A    | 2F    |
| 09    | BE    | D6    | 2C    |
| 83    | 4C    | 4A    | 5A    |
| 6E    | 15    | 15    | 4A    |

Exemples détaillés :
- 4D → ligne 4, col D → E3
- 40 → ligne 4, col 0 → 09
- 5A → ligne 5, col A → BE
- 2F → ligne 2, col F → 15

#### Question 4 — Après ShiftRows

Ligne 0 : décalage 0 | Ligne 1 : décalage 1 | Ligne 2 : décalage 2 | Ligne 3 : décalage 3

| col 0 | col 1 | col 2 | col 3 |
|-------|-------|-------|-------|
| E3    | 09    | 1A    | 2F    |
| BE    | D6    | 2C    | 09    |
| 4A    | 5A    | 83    | 4C    |
| 4A    | 6E    | 15    | 15    |

#### Question 5 — MixColumns (à comprendre, pas à calculer)

MixColumns traite chaque colonne indépendamment comme un polynôme sur GF(2⁸) et la multiplie par une matrice fixe. Après cette opération, chaque octet de sortie dépend des 4 octets de la colonne d'entrée → diffusion totale au sein d'une colonne.

#### Question 6 — Pourquoi 10 rounds ?

- Après 1 round (SubBytes + ShiftRows + MixColumns) : modifier 1 bit du message affecte en général 1 à 2 octets de sortie.
- Après 2 rounds : via ShiftRows + MixColumns en cascade, 4 à 8 octets sont affectés.
- Après 10 rounds : la propriété d'**avalanche** est complète — chaque bit de la sortie dépend statistiquement de chaque bit de l'entrée. En pratique, changer 1 bit du message change environ 50 % des bits du chiffré. C'est l'objectif de sécurité d'AES.

---

### Exercice 3 — Padding PKCS7

#### Question 1 — Calcul du padding

| Taille message (octets) | Octets ajoutés | Valeur des octets |
|-------------------------|----------------|-------------------|
| 13                      | 3              | 0x03              |
| 5                       | 11             | 0x0B              |
| 1                       | 15             | 0x0F              |
| 16                      | 16             | 0x10              |
| 31                      | 1              | 0x01              |

#### Question 2 — Retirer le padding

**a)** `48 65 6C 6C 6F | 0B 0B 0B 0B 0B 0B 0B 0B 0B 0B 0B`
→ Le dernier octet vaut 0x0B = 11 → on retire 11 octets de padding.
→ Message original : `Hello`

**b)** `54 65 73 74 21 21 21 21 21 21 21 21 | 04 04 04 04`
→ Le dernier octet vaut 0x04 = 4 → on retire 4 octets de padding.
→ Message original : `Test!!!!!!!!` (12 caractères)

#### Question 3 — Pourquoi toujours padder, même un multiple de 16 ?

Si l'on ne paddait pas les messages dont la taille est déjà un multiple de 16, l'algorithme de dépaddage ne pourrait pas distinguer un message sans padding d'un message dont les derniers octets sont par coïncidence des valeurs valides de padding. En ajoutant toujours un bloc complet de `0x10` dans ce cas, on garantit que le dernier octet après déchiffrement indique toujours et sans ambiguïté le nombre d'octets à retirer.

---

### Exercice 4 — Le mode ECB est dangereux

#### Question 1

En ECB, chaque bloc est chiffré **indépendamment** avec la même clé. Donc si deux blocs en clair sont identiques, leurs chiffrés sont **nécessairement identiques**. Un attaquant peut détecter des répétitions dans le message clair sans connaître la clé.

#### Question 2 — Le salaire de Jane

**Réponse : Candidat 1** — `TO AV 6R FP Y5 VX C9`

**Justification :** Jack gagne `105 000 EUR/…` (format connu). Son chiffré a 6 blocs de 2 caractères, dont on peut identifier :
- `FP` = chiffrement de `00` (les deux zéros du montant)
- `VX` = chiffrement de `0 ` (zéro + espace séparateur)
- `C9` = chiffrement de `EU` (début de EUR)

Le candidat 1 (`TO AV 6R FP Y5 VX C9`) possède 7 blocs (salaire plus long = plus grand), et partage exactement `FP`, `VX` et `C9` avec Jack, ce qui confirme la présence de `00`, `0 ` et `EU` dans le salaire de Jane. Les 3 premiers blocs différents (`TO AV 6R`) correspondent à un montant plus élevé (ex : `1 2` `00 ` `000` → plus d'un million). Jane étant la patronne, ce salaire supérieur est cohérent.

#### Question 3 — ECB et images

Les zones de couleur uniforme (ciel, murs, fond) produisent de nombreux blocs de pixels identiques. En ECB, ces blocs identiques donnent des chiffrés identiques : les contours et les grandes zones de couleur restent donc **visibles dans l'image chiffrée**. La structure de l'image originale transparaît malgré le chiffrement (c'est "l'effet pingouin").

---

### Exercice 5 — Le mode CBC

#### Question 1 — schéma

P1 ──⊕──[AES_K]──> C1
     ↑              ↓
     IV             |
                    ↓
P2 ──⊕──[AES_K]──> C2
     ↑              ↓
     C1             |
                    ↓
P3 ──⊕──[AES_K]──> C3
     ↑
     C2

#### Question 2 — Chiffrement CBC à la main

K = 5A, IV = 3C, blocs clairs : A1 B2 C3 D4
(Chiffrement simplifié : AES_K(x) = x ⊕ K)

| Étape | Calcul                              | Résultat |
|-------|-------------------------------------|----------|
| C1    | (A1 ⊕ 3C) = 9D, puis 9D ⊕ 5A       | C7   |
| C2    | (B2 ⊕ C7) = 75, puis 75 ⊕ 5A       | 2F   |
| C3    | (C3 ⊕ 2F) = EC, puis EC ⊕ 5A       | B6   |
| C4    | (D4 ⊕ B6) = 62, puis 62 ⊕ 5A       | 38   |

Chiffré : `C7 2F B6 38`

#### Question 3 — Déchiffrement CBC

K = 5A, IV = 3C, chiffré : `C7 2F B6 38`
(Déchiffrement simplifié : AES⁻¹_K(x) = x ⊕ K)

| Étape | Calcul                              | Résultat |
|-------|-------------------------------------|----------|
| P1    | dec(C7) = C7 ⊕ 5A = 9D, puis 9D ⊕ IV(3C) | A1 |
| P2    | dec(2F) = 2F ⊕ 5A = 75, puis 75 ⊕ C1(C7) | B2 |
| P3    | dec(B6) = B6 ⊕ 5A = EC, puis EC ⊕ C2(2F) | C3 |
| P4    | dec(38) = 38 ⊕ 5A = 62, puis 62 ⊕ C3(B6) | D4 |

Message récupéré : `A1 B2 C3 D4` ✓

#### Question 4 — Réflexion

**a)** Non, deux chiffrements du même message avec le même K mais des IV différents donnent des chiffrés différents, car dès le premier bloc le XOR avec l'IV produit un résultat distinct, qui se propage à tous les blocs suivants.

**b)** Si IV est réutilisé avec la même clé pour deux messages partageant le même premier bloc, alors leurs premiers blocs chiffrés sont identiques. Un attaquant peut détecter que les deux messages commencent pareil — fuite d'information partielle. C'est pourquoi l'IV doit être aléatoire et unique à chaque chiffrement.

**c)** En CBC, même si deux blocs en clair sont identiques, le XOR avec le bloc chiffré précédent (différent à chaque position) produit des entrées différentes pour AES → les blocs chiffrés sont différents. CBC masque les répétitions là où ECB les révèle.

---

### Exercice 6 — Attaque par clair connu sur XOR

#### Question 1 — Retrouver la clé

M = `48 45 4C 4C 4F` ("HELLO"), C = `68 65 6C 6C 6F`

K = M ⊕ C = `48⊕68  45⊕65  4C⊕6C  4C⊕6C  4F⊕6F` = `20 20 20 20 20`

**Clé K = 0x20** (espace ASCII, répété sur 1 octet)

#### Question 2 — Déchiffrement avec K = 0x20

C' = `77 6F 72 6C 64` ("world")

M' = C' ⊕ 0x20 = `57 4F 52 4C 44` = **"WORLD"**

#### Question 3 — Attaque à clair partiellement connu

Chiffré : `03 2D 2D 2B 2D 36 33 62 02 2D 2B 20 24`
Clair connu : `Bonjour` = `42 6F 6E 6A 6F 75 72`

**a)** 7 premiers octets de la clé :
```
03 ⊕ 42 = 41 ('A')
2D ⊕ 6F = 42 ('B')
2D ⊕ 6E = 43 ('C')
2B ⊕ 6A = 41 ('A')
2D ⊕ 6F = 42 ('B')
36 ⊕ 75 = 43 ('C')
33 ⊕ 72 = 41 ('A')
```
→ Clé partielle : `41 42 43 41 42 43 41` = `ABCABCA`

**b)** La séquence `ABC` se répète → **longueur de la clé = 3 octets** : `ABC`

**c)** Déchiffrement complet avec la clé `ABC` (période 3) :
```
Message = chiffré ⊕ clé répétée = "Bonjour Alice"
```

#### Question 4 — Discussion

**a)** Le XOR avec clé courte est vulnérable car la clé se répète. Avec un clair connu partiel, on récupère immédiatement les octets de clé correspondants. L'analyse statistique des fréquences ou la détection de la période (indice de coïncidence) permet de casser le chiffrement même sans clair connu.

**b)** Le One-Time Pad (OTP) — clé aussi longue que le message, utilisée une seule fois — est **théoriquement incassable** (Shannon, 1949). En pratique il pose deux problèmes majeurs : (1) distribuer secrètement une clé aussi longue que le message est aussi difficile que distribuer le message lui-même ; (2) réutiliser la même clé pour deux messages différents (two-time pad) brise immédiatement la sécurité, car M1 ⊕ M2 = C1 ⊕ C2 révèle des informations sur les deux messages.

---

## Exercices Python

### Partie 7 — ECB et blocs identiques

**Les deux blocs chiffrés sont-ils identiques ? OUI**

En AES-ECB, les deux blocs `AAAAAAAAAAAAAAAA` produisent exactement le même chiffré, puisque chaque bloc est chiffré indépendamment avec la même clé et que les entrées sont identiques.

**Implications pour la sécurité :** ECB préserve les patterns du message clair dans le chiffré. Un attaquant peut détecter des blocs répétés dans le message (données structurées, images, bases de données) sans connaître la clé. Il peut aussi réorganiser ou rejouer des blocs chiffrés pour modifier le message déchiffré. ECB ne doit jamais être utilisé en pratique pour chiffrer des données de taille > 1 bloc.

### Partie 8 — Effet pingouin

- **tux_ecb.bmp :** Le contour du pingouin reste clairement visible. Les grandes zones de couleur uniforme (fond noir, ventre blanc) produisent des blocs identiques qui se chiffrent de façon identique, préservant la structure visuelle de l'image.

- **tux_cbc.bmp :** L'image ressemble à du bruit aléatoire. Aucune forme n'est distinguable ; il est impossible de deviner que l'original représentait un pingouin.

- **Pourquoi ECB révèle des informations :** Chaque bloc de 16 pixels est chiffré indépendamment. Deux zones de même couleur donnent les mêmes 16 pixels → même bloc chiffré → même couleur dans le résultat. La carte des couleurs est brouillée mais la carte des *positions* identiques reste intacte.

- **Pourquoi CBC ne le fait pas :** Chaque bloc est XORé avec le chiffré du bloc précédent avant chiffrement. Même deux blocs de pixels identiques donnent des chiffrés différents (car leur "historique" diffère). L'output est statistiquement uniforme et indistinguable d'un bruit aléatoire.

### Partie 9 — CBC et blocs identiques

**Les deux blocs chiffrés sont-ils identiques en CBC ? NON**

Le premier bloc est XORé avec l'IV aléatoire, le second avec le chiffré du premier bloc — deux valeurs différentes. Malgré un clair identique, les entrées du chiffrement AES sont différentes pour chaque bloc.

**Comparaison avec ECB :** En ECB, deux blocs clairs identiques → deux blocs chiffrés identiques (déterministe, sans contexte). En CBC, l'enchaînement des blocs ("chaining") garantit que le contexte historique rend chaque bloc chiffré unique, même si le clair se répète.

---

## Difficultés rencontrées

-La S-Box de l'exercice 2 n'était fournie que partiellement dans l'énoncé, ce qui a nécessité de chercher les lignes manquantes.
-L'exercice 4 (salaire de Jane) m'a demandé un très gros moment de réflexion pour identifier quels blocs chiffrés correspondaient à quoi dans le format du salaire.
-La mise en place de la bibliothèque cryptography et la compréhension de son API (encryptor/decryptor, padder/unpadder) a nécessité de lire la documentation.