---
title: "Lab : hacher, chiffrer et signer avec OpenSSL"
domain: cybersecurity
level: beginner
duration: "45 min"
cost: "gratuit"
environment: "votre propre ordinateur (Linux, macOS ou Windows avec WSL2) avec OpenSSL 3.0 ou ultérieur ; accès à Internet pour la dernière étape uniquement"
lang: fr
source_hash: a5518221ad4e
---

# Lab : hacher, chiffrer et signer avec OpenSSL

## Objectif
Essayez chaque outil de la leçon sur un minuscule fichier texte avec la commande `openssl` : hachez-le, chiffrez-le avec un mot de passe, signez-le avec une paire de clés et transformez une clé en certificat. Lisez ensuite la véritable chaîne de certificats de `example.com`, comme le fait votre navigateur.

## Objectifs
- Calculer un condensat SHA-256 et constater que la modification d'un seul caractère le change complètement.
- Chiffrer et déchiffrer un fichier avec un mot de passe, et voir ce qui se passe avec un mauvais mot de passe et avec un fichier altéré.
- Créer une paire de clés, signer un fichier, vérifier la signature et voir la vérification échouer après une modification.
- Créer un certificat auto-signé et lire ses champs.
- Identifier le sujet, l'émetteur, les dates de validité et le SAN dans une véritable chaîne de certificats.

## Prérequis
- OpenSSL 3.0 ou ultérieur. Vérifiez-le avec `openssl version`. Il doit afficher `OpenSSL 3.x`, et non `LibreSSL` ni `1.1.1`.
- Un terminal. Sous Windows, utilisez WSL2.
- Un accès à Internet pour l'étape 7 uniquement.
- [La leçon Bases de la cryptographie](lesson.fr.md) de ce module.

> [!WARNING]
> Tout ce que vous faites aux étapes 1 à 6 se déroule sur votre propre ordinateur, avec des fichiers que vous créez. L'étape 7 **se connecte seulement au port 443 de `example.com` et lit le certificat qu'il présente**, exactement comme le fait un navigateur. Ne dirigez pas `openssl s_client` vers des systèmes qui ne vous appartiennent pas ou que vous n'avez pas le droit de tester, et ne leur envoyez rien d'autre.

> [!NOTE]
> Les clés et les mots de passe de ce lab ne servent qu'à s'exercer. Ne réutilisez jamais une clé du lab pour quoi que ce soit de réel, et ne saisissez jamais un vrai mot de passe sur une ligne de commande : il est visible dans la liste des processus et enregistré dans l'historique de votre shell.

## Architecture
![Scénario du lab. À gauche, une zone pour votre ordinateur, dossier ~/crypto-lab, avec quatre cartes. Étape 2, hachage : message.txt, avec sha256sum et openssl dgst. Étapes 3 et 4, chiffrement : message.enc, avec openssl enc et AES-256-CBC. Étape 5, signature : private.pem, public.pem et message.sig avec Ed25519. Étape 6, certificat : server.crt et server.key, avec openssl req et openssl x509. À droite, une zone en lecture seule pour Internet avec l'étape 7, la véritable chaîne de certificats de example.com sur le port 443, lue avec openssl s_client.](../../../assets/diagrams/crypto-lab-architecture.fr.svg)

*Figure 1. Les étapes 2 à 6 restent sur votre ordinateur ; l'étape 7 ne fait que lire un certificat public.*

## Étapes

### Étape 1 — Créer un dossier de travail et un fichier (3 min)
Vous travaillez dans un seul dossier, de sorte que le nettoyage final tienne en une seule commande. Le fichier est une minuscule « instruction bancaire » que vous allez protéger de différentes manières.

```bash
openssl version
mkdir ~/crypto-lab
cd ~/crypto-lab
printf 'Transfer 100 EUR to account ES00 1234\n' > message.txt
cat message.txt
```

Ce que fait chaque ligne : `openssl version` vérifie l'outil ; `mkdir` et `cd` créent le dossier et s'y placent ; `printf` écrit une ligne dans `message.txt` ; `cat` l'affiche.

Sortie attendue (la date de compilation après la version diffère sur votre ordinateur, tant qu'elle commence par `OpenSSL 3`) :
```text
OpenSSL 3.5.8 25 Aug 2026 (Library: OpenSSL 3.5.8 25 Aug 2026)
Transfer 100 EUR to account ES00 1234
```

### Étape 2 — Hacher le fichier et modifier un caractère (8 min)
Un hachage est une empreinte du fichier. Calculez-le de deux façons : `sha256sum` (Linux et WSL2 ; sous macOS, utilisez `shasum -a 256`) et `openssl dgst`.

```bash
sha256sum message.txt
openssl dgst -sha256 message.txt
```

Sortie attendue :
```text
190fd1598c81d23bd943f4ba864859db3039ab305e60a50bee9bec461d4b092f  message.txt
SHA2-256(message.txt)= 190fd1598c81d23bd943f4ba864859db3039ab305e60a50bee9bec461d4b092f
```

Remarquez : les deux outils affichent **les mêmes 64 caractères hexadécimaux**. Relancez l'une ou l'autre commande et vous obtenez chaque fois le même condensat.

Faites maintenant une copie où `100` devient `900`, et hachez-la :

```bash
sed 's/100/900/' message.txt > message2.txt
cat message2.txt
sha256sum message2.txt
```

Sortie attendue :
```text
Transfer 900 EUR to account ES00 1234
10bfa161dcd38705488563c4f86395ad2456430fe5b97d08fbbfc8c8322f96c5  message2.txt
```

Comparez avec le premier condensat. Un seul caractère a changé dans le fichier, et pourtant le condensat paraît sans aucun rapport : c'est l'**effet avalanche**. La longueur est toujours de 64 caractères.

Utilisez enfin le condensat comme vous le feriez pour vérifier un téléchargement. Enregistrez le condensat dans un fichier, puis demandez à `sha256sum` de contrôler le fichier par rapport à lui, avant et après l'altération :

```bash
sha256sum message.txt > SHA256SUMS
sha256sum -c SHA256SUMS
cp message.txt original.txt
cp message2.txt message.txt
sha256sum -c SHA256SUMS
cp original.txt message.txt
sha256sum -c SHA256SUMS
```

`-c` signifie « check » (contrôler). Les deux commandes `cp` remplacent d'abord `message.txt` par la version modifiée (en simulant l'action d'un attaquant), puis la restaurent.

Sortie attendue (les mots sont traduits dans d'autres langues) :
```text
message.txt: OK
message.txt: FAILED
sha256sum: WARNING: 1 computed checksum did NOT match
message.txt: OK
```

<details>
<summary>Question : un condensat qui correspond prouve-t-il que le fichier vient du véritable auteur ?</summary>

Non. Il prouve que le fichier est identique à celui qui a été haché. Si un attaquant peut modifier le fichier, il peut aussi modifier `SHA256SUMS`. Pour prouver **qui** a créé le fichier, il faut une clé : c'est la signature que vous créez à l'étape 5.

</details>

### Étape 3 — Chiffrer et déchiffrer avec un mot de passe (8 min)
Passons à la confidentialité. `openssl enc` chiffre un fichier avec AES-256 et une clé issue de votre mot de passe. L'option `-pbkdf2 -iter 600000` fait dériver la clé du mot de passe par openssl avec PBKDF2, lentement, et `-salt` ajoute un sel aléatoire (c'est de nouveau l'idée de hachage de mots de passe de la leçon).

```bash
openssl enc -aes-256-cbc -pbkdf2 -iter 600000 -salt -pass pass:correct-horse -in message.txt -out message.enc
wc -c message.enc
xxd message.enc
```

`-pass pass:correct-horse` donne le mot de passe sur la ligne de commande, ce qui n'est acceptable que pour un lab (voir la note ci-dessus). `wc -c` compte les octets. `xxd` affiche le fichier en hexadécimal, car le texte chiffré n'est pas du texte lisible.

Sortie attendue (tout ce qui suit `Salted__` varie à chaque exécution, car le sel est aléatoire) :
```text
64 message.enc
00000000: 5361 6c74 6564 5f5f 1865 220a 69f3 72b9  Salted__.e".i.r.
00000010: f14c 9111 b8a4 ce73 cd80 41b5 21c6 2ab0  .L.....s..A.!.*.
00000020: b186 557a af33 e545 2692 f807 cd4b 02ef  ..Uz.3.E&....K..
00000030: 9582 5a70 821b b6e4 ff27 f526 190c 0762  ..Zp.....'.&...b
```

Remarquez : le fichier commence par le mot `Salted__` et 8 octets de sel, et le reste paraît aléatoire. Le texte d'origine n'est pas visible. Il fait 64 octets : 8 pour `Salted__`, 8 pour le sel et 48 pour les données chiffrées (le message de 38 octets est complété jusqu'à un multiple de 16).

Déchiffrez-le avec le bon mot de passe :

```bash
openssl enc -d -aes-256-cbc -pbkdf2 -iter 600000 -pass pass:correct-horse -in message.enc
```

`-d` signifie déchiffrer. Vous devez donner **le même** algorithme et la même valeur de `-iter`.

Sortie attendue :
```text
Transfer 100 EUR to account ES00 1234
```

Essayez maintenant un mauvais mot de passe. Envoyez la sortie dans un fichier, car une mauvaise clé produit des données inintelligibles :

```bash
openssl enc -d -aes-256-cbc -pbkdf2 -iter 600000 -pass pass:wrong-guess -in message.enc -out bad.txt
rm bad.txt
```

Sortie attendue (le code hexadécimal au début de la deuxième ligne varie) :
```text
bad decrypt
00332243777F0000:error:1C800064:Provider routines:ossl_cipher_unpadblock:bad decrypt:providers/implementations/ciphers/ciphercommon_block.c:107:
```

Remarquez : le mauvais mot de passe ne révèle rien ; vous obtenez une erreur. La commande `rm` supprime le fichier inintelligible qui a été laissé.

> [!NOTE]
> L'erreur n'est pas garantie. Avec ce mode, environ 1 mauvais mot de passe sur 256 produit par hasard un bourrage valide : `openssl` n'affiche alors aucune erreur et la sortie est inintelligible. Le mode n'a aucun moyen de dire « cette clé est fausse ». L'étape 4 montre une faiblesse plus grave du même ordre.

### Étape 4 — Pourquoi il faut un chiffrement authentifié (6 min)
La leçon dit qu'AES-CBC n'apporte aucune intégrité. Vérifiez-le. La commande ci-dessous modifie **un octet** au milieu de `message.enc`, comme pourrait le faire un attaquant. `dd` écrase par un zéro l'octet situé à la position 32.

```bash
cp message.enc tampered.enc
printf '\000' | dd of=tampered.enc bs=1 seek=32 conv=notrunc 2>/dev/null
openssl enc -d -aes-256-cbc -pbkdf2 -iter 600000 -pass pass:correct-horse -in tampered.enc -out tampered.txt
echo "exit code: $?"
xxd tampered.txt
```

Sortie attendue (les octets brouillés de la deuxième ligne et l'octet modifié au début de la troisième ligne varient, car le sel est aléatoire) :
```text
exit code: 0
00000000: 5472 616e 7366 6572 2031 3030 2045 5552  Transfer 100 EUR
00000010: 63a6 2f97 15ae 6556 aa6a 448b 2a17 3791  c./...eV.jD.*.7.
00000020: 9131 3233 340a                           .1234.
```

Remarquez trois choses. La commande indique un **succès** (code de sortie 0). Les 16 premiers caractères sont corrects. Les 16 suivants sont inintelligibles, et l'espace au début de la dernière ligne (avant `1234`) a été remplacé par un autre octet. OpenSSL n'a pas détecté l'altération : c'est pourquoi les protocoles modernes utilisent un chiffrement **authentifié** (AEAD) tel qu'AES-GCM, qui échoue dès qu'un seul bit change.

Demandez à `openssl enc` d'en utiliser un :

```bash
openssl enc -aes-256-gcm -pbkdf2 -pass pass:x -in message.txt -out /dev/null
```

Sortie attendue :
```text
enc: AEAD ciphers not supported
enc: Use -help for summary.
```

C'est une limite assumée de l'outil : `openssl enc` ne sait pas faire AES-GCM. Il convient pour apprendre, pas pour protéger de vraies données. Pour de vrais fichiers, utilisez un outil maintenu fondé sur le chiffrement authentifié, comme `age` ou GnuPG, et, dans vos programmes, une bibliothèque qui fournit AES-GCM ou ChaCha20-Poly1305.

<details>
<summary>Question : pourquoi le déchiffrement a-t-il « réussi » avec un fichier endommagé ?</summary>

CBC se borne à retransformer des blocs d'octets en texte clair. Il n'a pas de valeur de contrôle (ni MAC, ni étiquette) et ne peut donc pas savoir que le texte chiffré a été modifié. Le dommage apparaît sous forme de données inintelligibles dans le bloc qui suit l'octet modifié, plus un octet inversé dans le bloc suivant. Un mode AEAD ajoute une étiquette d'authentification et refuse de déchiffrer si l'étiquette ne correspond pas.

</details>

### Étape 5 — Signer un fichier et vérifier la signature (8 min)
Passons à l'authenticité. Vous créez une **paire de clés** avec l'algorithme Ed25519, vous signez `message.txt` avec la clé **privée** et vous la vérifiez avec la clé **publique**.

```bash
openssl genpkey -algorithm ED25519 -out private.pem
openssl pkey -in private.pem -pubout -out public.pem
cat public.pem
```

`genpkey` génère la clé privée. `pkey -pubout` en dérive la clé publique. Seule la clé publique est destinée à être partagée.

Sortie attendue (le texte de votre clé est différent) :
```text
-----BEGIN PUBLIC KEY-----
MCowBQYDK2VwAyEAVPF2/34u81ANojBZJ/uT7OQ+7sX3ui2HiaKGVgG8t98=
-----END PUBLIC KEY-----
```

Regardez les permissions du fichier de clé privée. Sous Linux, OpenSSL le crée lisible par vous seul :

```bash
ls -l private.pem
```

Sortie attendue (le propriétaire, la date et les caractères supplémentaires varient) :
```text
-rw------- 1 user user 119 Nov  7 20:40 private.pem
```

`-rw-------` signifie que vous seul pouvez le lire et y écrire. Une clé privée doit toujours être ainsi.

Signez le message :

```bash
openssl pkeyutl -sign -inkey private.pem -rawin -in message.txt -out message.sig
wc -c message.sig
```

`pkeyutl -sign` signe avec la clé privée. `-rawin` lui indique de prendre le fichier entier comme entrée. Ed25519 hache le fichier à l'intérieur de l'algorithme ; vous n'avez donc pas à le hacher d'abord.

Sortie attendue :
```text
64 message.sig
```

Une signature Ed25519 fait toujours 64 octets, quelle que soit la taille du fichier. Vérifiez maintenant avec la clé **publique** :

```bash
openssl pkeyutl -verify -pubin -inkey public.pem -rawin -in message.txt -sigfile message.sig
```

`-pubin` indique que la clé fournie est une clé publique.

Sortie attendue :
```text
Signature Verified Successfully
```

Essayez à présent de vérifier la même signature par rapport au fichier **modifié**, `message2.txt` (celui à 900 EUR) :

```bash
openssl pkeyutl -verify -pubin -inkey public.pem -rawin -in message2.txt -sigfile message.sig
```

Sortie attendue (le code au début de la première ligne varie) :
```text
005364386B7F0000:error:030000EA:digital envelope routines:EVP_DigestVerify:provider signature failure:crypto/evp/m_sigver.c:795:ED25519 digest_verify:
Signature Verification Failure
```

Remarquez : un seul caractère modifié et la signature ne correspond plus. Personne ne peut la corriger sans la clé privée. Contrairement au hachage de l'étape 2, un attaquant ne peut pas remplacer la signature pour qu'elle corresponde à un fichier altéré.

<details>
<summary>Question : qui a besoin de la clé privée, et qui a besoin de la clé publique ?</summary>

Le **signataire** a besoin de la clé privée pour créer des signatures. **Toute personne qui veut vérifier** a besoin de la clé publique. C'est pourquoi vous pouvez publier librement la clé publique et devez protéger la clé privée. La question restante, « s'agit-il bien de la clé publique de l'auteur ? », trouve sa réponse dans les certificats, à l'étape suivante.

</details>

### Étape 6 — Créer un certificat auto-signé et le lire (7 min)
Un certificat lie une clé publique à un nom. Une seule commande crée une nouvelle paire de clés et un certificat **auto-signé** (signé par sa propre clé, sans AC) pour un nom fictif sur le domaine réservé `example.org`, valide 30 jours.

```bash
openssl req -x509 -newkey ed25519 -nodes -keyout server.key -out server.crt -days 30 \
  -subj "/CN=lab.example.org/O=CloudAcademia Lab" -addext "subjectAltName=DNS:lab.example.org"
```

Signification des options : `req -x509` produit un certificat plutôt qu'une demande ; `-newkey ed25519` crée une nouvelle clé ; `-nodes` laisse la clé privée non chiffrée (pour le lab uniquement) ; `-keyout` et `-out` nomment les fichiers ; `-days 30` fixe la validité ; `-subj` renseigne les champs de nom ; `-addext` ajoute le SAN.

Sortie attendue :
```text
-----
```

Lisez les champs de certificat appris dans la leçon :

```bash
openssl x509 -in server.crt -noout -subject -issuer -dates -ext subjectAltName,basicConstraints
```

Sortie attendue (les dates sont espacées de 30 jours, à partir du moment où vous avez lancé la commande) :
```text
subject=CN=lab.example.org, O=CloudAcademia Lab
issuer=CN=lab.example.org, O=CloudAcademia Lab
notBefore=Nov  7 19:40:39 2026 GMT
notAfter=Dec  7 19:40:39 2026 GMT
X509v3 Basic Constraints: critical
    CA:TRUE
X509v3 Subject Alternative Name: 
    DNS:lab.example.org
```

Remarquez : **le sujet et l'émetteur sont identiques**. C'est ce que signifie « auto-signé ». Pour tout voir, y compris la clé publique et la signature, affichez le texte complet :

```bash
openssl x509 -in server.crt -noout -text
```

Sortie attendue (abrégée ; le numéro de série, la clé et les octets de la signature varient) :
```text
Certificate:
    Data:
        Version: 3 (0x2)
        Serial Number:
            7f:8f:86:e8:fe:a8:69:a8:09:be:68:86:59:17:31:37:61:10:f1:7d
        Signature Algorithm: ED25519
        Issuer: CN=lab.example.org, O=CloudAcademia Lab
        Validity
            Not Before: Nov  7 19:40:39 2026 GMT
            Not After : Dec  7 19:40:39 2026 GMT
        Subject: CN=lab.example.org, O=CloudAcademia Lab
        Subject Public Key Info:
            Public Key Algorithm: ED25519
                ED25519 Public-Key:
                pub:
                    a7:11:42:5a:60:88:0d:5f:6b:41:97:23:f1:ba:5d:
                    ...
        X509v3 extensions:
            X509v3 Subject Key Identifier: 
                84:24:8A:08:11:DC:3E:B5:44:DF:38:19:3B:90:9F:73:58:49:EA:D5
            X509v3 Authority Key Identifier: 
                84:24:8A:08:11:DC:3E:B5:44:DF:38:19:3B:90:9F:73:58:49:EA:D5
            X509v3 Basic Constraints: critical
                CA:TRUE
            X509v3 Subject Alternative Name: 
                DNS:lab.example.org
    Signature Algorithm: ED25519
    Signature Value:
        76:9f:98:3e:86:ac:f9:27:2b:f6:78:4d:56:2a:33:94:14:c3:
        ...
```

Repérez chaque champ : Serial Number, Issuer, Validity, Subject, Subject Public Key Info, les extensions (SAN, Basic Constraints) et la Signature de l'émetteur.

Voyez maintenant pourquoi les navigateurs ne lui font pas confiance. Demandez à OpenSSL de le vérifier par rapport à la liste de racines de confiance de votre ordinateur, puis par rapport à lui-même :

```bash
openssl verify server.crt
openssl verify -CAfile server.crt server.crt
```

Sortie attendue :
```text
CN=lab.example.org, O=CloudAcademia Lab
error 18 at 0 depth lookup: self-signed certificate
error server.crt: verification failed
server.crt: OK
```

Remarquez : la première vérification échoue parce qu'aucune AC de votre **magasin de racines** ne se porte garante de ce certificat. La seconde réussit uniquement parce que vous avez demandé à OpenSSL de faire confiance vous-même à ce certificat précis. La confiance d'un navigateur repose sur la même idée, avec une centaine de racines déjà installées.

### Étape 7 — Lire la véritable chaîne de certificats de example.com (5 min)
Cette étape nécessite Internet. `openssl s_client` ouvre une connexion TLS comme un navigateur. `-servername example.com` envoie le nom du serveur pour que celui-ci choisisse le bon certificat. `</dev/null` termine aussitôt la session, de sorte que rien d'autre n'est envoyé.

```bash
openssl s_client -connect example.com:443 -servername example.com </dev/null > chain.txt 2>&1
sed -n '/^Certificate chain/,/^---/p' chain.txt
```

La première commande enregistre toute la sortie dans `chain.txt` ; `sed` n'affiche que la section de la chaîne.

> [!NOTE]
> Il s'agit d'un véritable site web : **votre sortie différera de celle ci-dessous**. Le certificat est renouvelé toutes les quelques semaines ou quelques mois, et les autorités de certification, la longueur de la chaîne et les algorithmes peuvent changer. Cherchez les mêmes types d'informations, non les mêmes valeurs.

Sortie attendue (abrégée aux deux premiers certificats ; votre liste peut être plus courte ou plus longue) :
```text
Certificate chain
 0 s:CN=example.com
   i:C=US, O=SSL Corporation, CN=Cloudflare TLS Issuing ECC CA 3
   a:PKEY: EC, (prime256v1); sigalg: ecdsa-with-SHA256
   v:NotBefore: Sep 26 22:49:11 2026 GMT; NotAfter: Dec 25 22:56:35 2026 GMT
 1 s:C=US, O=SSL Corporation, CN=Cloudflare TLS Issuing ECC CA 3
   i:C=US, O=SSL Corporation, CN=SSL.com TLS Transit ECC CA R2
   a:PKEY: EC, (prime256v1); sigalg: ecdsa-with-SHA384
   v:NotBefore: May 29 19:49:45 2025 GMT; NotAfter: May 27 19:49:44 2035 GMT
 ...
---
```

Lisez-la ainsi : `s:` est le **sujet** (*subject*) et `i:` est l'**émetteur** (*issuer*). Le certificat 0 est la **feuille** de `example.com`, émise par l'AC intermédiaire qu'est le certificat 1. L'émetteur de chaque certificat est le sujet du suivant : c'est la chaîne. `v:` donne les dates de validité. Les derniers certificats de la liste sont les AC situées au-dessus de l'intermédiaire.

Voyez maintenant ce que la connexion a utilisé et si votre ordinateur lui a fait confiance :

```bash
grep -E "Protocol|Cipher is|Verification:" chain.txt
```

Sortie attendue :
```text
Verification: OK
New, TLSv1.3, Cipher is TLS_AES_256_GCM_SHA384
Protocol: TLSv1.3
```

Remarquez : **TLS 1.3** avec un algorithme **AES-GCM**, l'hybride de la leçon. `Verification: OK` signifie que la chaîne se termine par une racine présente dans votre magasin de racines. Vos valeurs peuvent différer (par exemple `TLS_AES_128_GCM_SHA256`).

Lisez enfin les détails du certificat feuille avec la commande `x509` utilisée à l'étape 6. `openssl x509` lit le premier certificat du fichier, la feuille :

```bash
openssl x509 -in chain.txt -noout -subject -issuer -dates -ext subjectAltName
```

Sortie attendue :
```text
subject=CN=example.com
issuer=C=US, O=SSL Corporation, CN=Cloudflare TLS Issuing ECC CA 3
notBefore=Sep 26 22:49:11 2026 GMT
notAfter=Dec 25 22:56:35 2026 GMT
X509v3 Subject Alternative Name: 
    DNS:example.com, DNS:*.example.com
```

Répondez à ces questions avec **votre** sortie :

1. Qui est le sujet et qui est l'émetteur du certificat feuille ?
2. Pendant combien de jours le certificat est-il valide ?
3. Quels noms le SAN liste-t-il ? Le certificat serait-il valide pour `www.example.com` ? Et pour `a.b.example.com` ?

<details>
<summary>Afficher les réponses (pour la sortie ci-dessus)</summary>

1. Le sujet est `CN=example.com` ; l'émetteur est l'AC intermédiaire `Cloudflare TLS Issuing ECC CA 3`.
2. Du 26 septembre au 25 décembre 2026 : environ 90 jours. Les certificats publics ont une durée de vie courte, comme l'explique la leçon.
3. `example.com` et `*.example.com`. `www.example.com` correspond au caractère générique. `a.b.example.com` n'y correspond pas : un caractère générique ne couvre qu'une seule étiquette.

Vos propres réponses différeront, mais la méthode est la même : lire le sujet, l'émetteur, `NotBefore` et `NotAfter`, et le SAN.

</details>

## Vérification
Vérifiez que vous avez obtenu les résultats essentiels. Toutes ces conditions doivent être remplies :

```bash
sha256sum -c SHA256SUMS
openssl pkeyutl -verify -pubin -inkey public.pem -rawin -in message.txt -sigfile message.sig
openssl verify -CAfile server.crt server.crt
```

Sortie attendue :
```text
message.txt: OK
Signature Verified Successfully
server.crt: OK
```

Vous réussissez si :
- le condensat du fichier d'origine correspond (`OK`) et le fichier modifié a donné un condensat différent à l'étape 2 ;
- le bon mot de passe a déchiffré le fichier et un mauvais a produit `bad decrypt` ;
- la signature a été vérifiée pour `message.txt` et a échoué pour `message2.txt` ;
- vous avez pu désigner le sujet, l'émetteur, les dates de validité et le SAN de `example.com` à l'étape 7.

## Dépannage
| Symptôme | Cause probable | Solution |
|---|---|---|
| `openssl version` affiche `LibreSSL` ou `OpenSSL 1.1.1`, ou `pkeyutl` ne connaît pas `-rawin` | Une version d'OpenSSL plus ancienne ou différente (celle de macOS par défaut est LibreSSL) | Utilisez OpenSSL 3.0 ou ultérieur : installez-le (par exemple avec Homebrew sous macOS) ou utilisez WSL2 sous Windows |
| `Signature Verification Failure` à l'étape 5 pour `message.txt` | Vous avez modifié `message.txt` après la signature, ou vous avez signé un autre fichier | Refaites `openssl pkeyutl -sign` sur le `message.txt` actuel. L'échec pour `message2.txt` est normal |
| `bad decrypt` lors du déchiffrement avec le bon mot de passe | Un `-iter` ou un algorithme différent de celui du chiffrement, ou une faute de frappe dans le mot de passe | Utilisez exactement les mêmes options et le même mot de passe que dans la commande de chiffrement |
| `error 18 ... self-signed certificate` avec `openssl verify server.crt` | Normal : aucune AC de confiance ne l'a signé | Utilisez `-CAfile server.crt` comme à l'étape 6 pour lui faire confiance explicitement |
| Erreurs `connect: Connection refused`, `Connection timed out` ou `getaddrinfo` à l'étape 7 | Pas d'accès à Internet, ou un pare-feu ou un proxy bloque le port 443 | Vérifiez votre connexion et réessayez ; un proxy peut modifier la chaîne que vous voyez. Passez l'étape 7 si le réseau est restreint |
| `sha256sum: command not found` sous macOS | macOS fournit `shasum` à la place | Utilisez `shasum -a 256 message.txt` |
| La ligne `Verification:` est absente ou indique une erreur | Votre ordinateur n'a pas de bundle d'AC, ou son horloge est fausse | Vérifiez la date du système et installez le paquet de certificats d'AC de votre système |

## Défi (facultatif)
1. Répétez l'étape 3 **sans** l'option `-iter`, puis avec `-iter 1000`. Déchiffrez chaque fichier. Pourquoi le nombre d'itérations compte-t-il pour un mot de passe, et que devez-vous retenir au moment du déchiffrement ?
2. Générez une paire de clés RSA avec `openssl genpkey -algorithm RSA -pkeyopt rsa_keygen_bits:3072 -out rsa-key.pem`, dérivez-en la clé publique comme à l'étape 5 (nommez-la `rsa.pub`), et signez `message.txt` avec `openssl pkeyutl -sign -inkey rsa-key.pem -rawin -digest sha256 -in message.txt -out rsa.sig`. Vérifiez-la de la même façon (ajoutez aussi `-digest sha256` à la commande de vérification). Comparez la taille de la signature et celle du fichier de clé publique avec celles d'Ed25519 (indice : 384 octets contre 64).
3. À l'étape 7, connectez-vous à `example.org` à la place et comparez la chaîne, l'émetteur et le SAN avec ceux de `example.com`.

## Nettoyage
Le lab a créé un seul dossier dans votre répertoire personnel, et rien d'autre. Supprimez-le, avec les clés qu'il contient :

```bash
cd ~
rm -r ~/crypto-lab
```

Vérifiez qu'il a disparu :

```bash
ls ~/crypto-lab
```

Sortie attendue :
```text
ls: cannot access '/home/<you>/crypto-lab': No such file or directory
```

Rien n'a été installé et aucun magasin de confiance du système n'a été modifié.

## Ce que vous avez appris
- Un hachage est une empreinte de taille fixe et reproductible : un seul caractère modifié donne un condensat complètement différent. Il montre l'intégrité, mais tout le monde peut le recalculer ; il ne prouve donc pas qui a écrit le fichier.
- Le chiffrement par mot de passe avec `openssl enc` cache le contenu, mais le mode CBC ne peut pas détecter l'altération. Préférez le chiffrement authentifié (AES-GCM, ChaCha20-Poly1305) au moyen d'une bibliothèque ou d'un outil adapté.
- Une signature produite avec une clé privée est vérifiée avec la clé publique et devient invalide lorsque le fichier change. Gardez la clé privée privée (permissions `600`).
- Un certificat lie un nom (le SAN) à une clé publique ; un certificat auto-signé n'inspire confiance à personne tant que vous ne le décidez pas, alors qu'un vrai certificat est relié par une chaîne à une racine du magasin de racines.
- `openssl s_client` montre ce que voit votre navigateur : la chaîne, les dates de validité, la version de TLS et l'algorithme de chiffrement.
