Openssl
Vous pouvez utiliser les fonctionnalités suivantes :
```bash
openssl genrsa -out fichier_rsa.priv size
```
génére la clé privé RSA de taille size. les valeurs possible pour size
sont : 512, 1024, etc.
```bash
openssl rsa -in fichier_rsa.priv -des3 -out fichier.pem
```
chiffre la clef privé RSA avec l'algorithme DES3. Vous pouvez utiliser DES, 3DES, IDEA,etc.
```bash
openssl rsa -in fichier_rsa.priv -pubout -out fichier_rsa.pub
```
stocke la partie publique dans un fichier à part (création de de la clé
publique associée à la clef privée dans le fichier fichier.pem).
```bash
openssl enc -algo -in claire.txt -out chiffre.enc
```
pour le chiffrement de claire.txt avec l'algorithme spécifié (`openssl enc --help` pour avoir la liste des possibilités ou bien openssl
list-cipher-commands) dans un fichier chiffre.enc.
```bash
openssl enc -algo -in chiffre -d -out claire
```
pour le déchiffrement.
```bash
openssl dgst -algo -out sortie entrée
```
pour hacher un fichier. L'option -algo est le choix de l'algorithme de
hachage (sha, sha1, dss1, md2,md4, md5, ripemd160).
```bash
openssl rand -out clé.key nombre_bits
```
pour générer un nombre aléatoire de taille nombre_bits (utiliser
l'option -base 64 pour la lisibilité).
```bash
openssl aes-256-cbc -in claire.txt -out chiffre.enc -e -k clé.key
```
pour chiffrer un fichier avec l'AES.
```bash
openssl rsautl -encrypt -inkey rsa.pub -in clair.txt -out chiffre.enc
```
chiffrer fichier.txt avec la RSA en utilisant la clef publique rsa.pub.
```bash
openssl rsautl -decrypt -inkey rsa.priv -in chiffre.enc -out fihcier.txt
```
pour déchiffrer le fichier fic.dec.
```bash
openssl rsautl -sign -inkey ras.priv -in fichier.txt -out fic.sig
```
pour générer une signature.
```bash
openssl rsautl -verify -pubin -inkey rsa.pub -in fic.sig
```
pour vérifier une signature.
### Chiffrage symétrique
#### Avec mot de passe
La liste des algorithme de chiffrement symétrique est donnée par la
commande
```bash
openssl enc -ciphers
```
Pour chiffrer le fichier toto avec le système Blowfish en mode CBC, avec
une clé générée par mot de passe, le chiffré étant stocké dans le
fichier toto.chiffre , on utilise la commande :
openssl enc -bf-cbc -in toto -out toto.chiffre
Pour déchiffrer le même message, on utilise la commande :
openssl enc -bf-cbc -d -in toto.chiffre -out toto.dechiffre
**Exercice 1**
- Chiffrer et déchiffrer un fichier de votre choix. Vérifier avec la
commande `diff`.
- Comment expliquer la différence de taille du fichier et du fichier
chiffré ?
- Que se passe-t-il si le mot de passe est invalide ?
- Ajouter l'option `-iter` et `-salt` ? à quoi cela sert-il ?
**Exercice 2**
Le cryptogramme [cryptogramme](./cryptogramme) a été chiffré avec AES en
mode CBC, la clé de 128 bits ayant été obtenue par mot de passe. Sachant
le codage en base 64 du mot de passe est `VHN1bmFtaQo=`, déchiffrez le
cryptogramme.
#### Avec clé explicite (mode CBC)
Pour chiffrer le fichier toto avec une clé explicite, il faut utiliser
les options -K (ou -kfile) et -iv
- `-K` ( K majuscule) suivi de la clé exprimée en hexadécimal ;
- `-iv` ( iv en minuscules) suivi du vecteur d'initialisation exprimé
en hexadécimal.
L'exemple qui suit montre la commande pour chiffrer toto avec Blowfish
en mode CBC avec un vecteur d'initialisation de 64 bits, et une clé de
128 bits :
openssl enc -bf-cbc -in toto -out toto.chiffre \
-iv 0123456789ABCDEF \
-K 0123456789ABCDEF0123456789ABCDEF
**Exercice 3**
Générez une clé pour aes-256, ainsi qu'un vecteur d'initialisation
(128 bits). Chiffrez et déchiffrez (AES 256 en mode CBC) le fichier
clair correspondant au cryptogramme de la question précédente.
### Chiffrage à clé publique
On peut générer des clés RSA avec la commande
openssl genrsa -out keyfile size
**Exercice 4**
Générez une clé RSA sur 2048 bits dans le fichier key.pem. Que donne
`cat key.pem.`
openssl rsa -in keyfile -text -noout
permet de visualiser vos clés
**Exercice 5**
- Exportez la partie publique de votre clé dans key.pub. Regardez le
fichier.
- Chiffrez la clé privée avec idea et un mot de passe. Regardez ce que
contient le fichier.
```bash
openssl rsa -in maCle.pem -idea -out maCle.pem
```
- Chiffrez "un petit fichier". Quelle est la taille du fichier
chiffré ? Déchiffrez-le.
- Que se passe-t-il pour un gros fichier ? pourquoi ?
- Chiffrez un message avec l'option `-oaep`, et recommencer, en vérifiant que le chiffré
change.
**Exercice 6**
Envoyez votre clé publique à un camarade. Celui-ci vous enverra la sienne.
Générer un petit fichier texte et envoyez-le à votre voisin chiffré avec
sa clef publique. Lui vous enverra un fichier chiffré avec sa clef.
Renvoyez-lui le message qu'il vous a envoyé mais en clair.
**Exercice 7**
Toujours en binome : A génére une clef AES 256 qu'il chiffre avec la
clef publique RSA de B et il lui envoye le chiffré. A partir de là, B
récupère la clef (en clair), et il chiffre un gros fichier avec l'AES et
la clef AES. Il envoie le gros fichier chiffré à A qui doit le
déchiffré.
### Hachage et mots de passe
Pour calculer un hachage, utiliez la commande
openssl dgst -algo -out hash fichier
**Exercice 8**
1. Visitez les possibilités de la commande prime d’OPENSSL.
2. Testez la primalité d’un nombre donné : en plus de la réponse, constatez que l'écho de ce nombre
a lieu en hexadécimal.
3. Testez la primalité d’un nombre passé directement en hexadécimal.
4. (facultatif) Ecrivez un petit shell-script UNIX de façon à faire afficher les nombres premiers d'un
intervalle donné (utilisez seq ou autre).
**Exercice 9**
1. À l'aide de la commande dgst, obtenir dans bash.hash, le hachage du
fichier exécutable `/usr/bin/bash`, en choisissant SHA256 (Secure
Hash Algorithm) comme algorithme de hashage. Refaire pour obtenir la
version binaire du hash dans le fichier executable.hash.bin.
Comparer la taille de `/usr/bin/bash`, de executable.hash et de
executable.hash.bin. Quelle est la longueur du hash en nombre de
bits ? On recommence avec un fichier court oof. Quelle est la
longueur du hash en nombre de bits ?
2. Changer un seul **bit** dans oof. Comment change le hash ?
3. On recommence avec MD5 (Digest Message) comme algorithme de hashage.
Quelle est la longueur des hashs en nombre de bits.
4. Récupérez les fichiers [fichier1](./M1.ps.gz) et
[fichier2](./M2.ps.gz). Décompressez-les, et regardez leur contenu.
5. Calculer leur empreinte MD5 avec `openssl`. Conclusion ?
6. Même question avec SHA-1 et SHA256.
7. S'il s'agit tout simplement de calculer des hashs, on peut utiliser
directement certaines commandes, sans passer par openssl. Par
exemple les commandes md5sum ou shasum. C'est le cas, par exemple,
lorsqu'on télécharge des packages dont on veut vérifier l'intégrité
de la copie (à condition bien sûr que le site officiel de l'éditeur
du package publie le hash du package).
**Exercice 10**
Vous vous retrouvez en possession du hachage MD5 d'un mot de passe que
vous voulez casser.
dde2790ce930e3d425305c36afd4e69c
Ecrivez un programme force brute qui teste tous les mots d'un
dictionnaire. Pour calculer le hachage MD5 d'une chaîne, utilisez la
fonction MD5 de openssl (-lcrypto à la compilation)
```c
#include