# Cryptographie - TP - 1

## 1. Chiffrement

### 1.1

```bash
openssl genrsa -out <fichier> <taille>
```

De quelle taille est la clé que vous avez créée sans donner la taille en paramètre ?

*La clé créée sans donner la taille en paramètre est de taille 2048 bits*

Quelle est votre conclusion ?

*Il est recommandé d'utiliser une clé de taille 2048 bits au minimum*

Existe-il d’autres formats que **.key** ?

*Oui il existe également `.pem`*

### 1.2

En quelle base est codée la clé ? 

*La clé est encodée en base64*

Quel est le rôle de chaque partie affichée ?

*Chaque partie affichée correspond à un des éléments de l'algorithme RSA*

L’exposant public par défaut est 65537, pour quelle raison ? d’après vous, cela pose-t-il des problèmes de sécurité ?

*Cela est du à une tradition historique car les première version de RSA étaient vulnérables à un exposant faible. Il a également été décidé que des nombres plus grands coûtaient cher avec aucun avantage en terme de sécurité. Cela ne pose pas de problème de sécurité car il s'agit d'un standard* 

> La clé publique est calculée à partir de la clé privée

### 1.3

Chiffrer priv.key à l’aide d’un cryptosystème symétrique de votre choix (privC.key)

```bash
openssl enc -a -aes-128-cbc -in priv.key -out privC.key
```

> On donne un mot de passe qui va être utilisé pour générer la clé utilisée pour le chiffrement symétrique ?

### 1.4

Afficher le contenu de privC.key

```bash
cat privC.key
```

Qu’est-ce que le Salted ?

*Le sel est une donnée aléatoire utilisées comme entrée additionnelle dans les fonctions de hachage (au début de la chaine chiffrée) pour éviter les collisions*

Peut-on utiliser cette clé telle quelle à l’avenir ?

*Non on ne peut pas l'utiliser, il faut la déchiffrer car elle n'est pas formattée en tant que clé chiffrée.*

### 1.5

Utiliser une seule commande pour générer une clé privée chiffrée avec aes128 (priv.key)

```bash
openssl genrsa -aes128 -out priv.key 2048
```

### 1.6

Générer la clé publique (pub.key)

```bash
openssl rsa -in priv.key -out pub.key
```

A-t-on besoin de spécifier la taille de la clé publique ? pour quelle raison ?

*La taille de la clé publique dépend de celle de la clé privée donc on a pas besoin de spécifier sa taille*

### 1.7

Créer deux fichiers texte : 

```
Texte.txt : Apple force l’industrie à adopter des certificats HTTPS d’un an… 29 juin 2020
```

TexteLong.txt : 

```
IBM publie une boite à outils visant à maintenir le chiffrement des données, même pendant leur
utilisation.
La nouvelle boîte à outils d'IBM vise à faciliter l'accès des développeurs au chiffrement
entièrement homomorphe, une technologie naissante très prometteuse pour un certain
nombre de cas d'utilisation de la sécurité. 08 juin 2020
```

### 1.8

Chiffrer Texte.txt et TexteLong.txt avec un cryptosystème symétrique de votre choix, et afficher le résultat.

```bash
openssl aes-256-cbc -a -salt -in Texte.txt -out TexteC.txt
openssl aes-256-cbc -a -salt -in TextLong.txt -out TextLongC.txt
cat TexteC.txt
cat TextLongC.txt
```

### 1.9

Chiffrer Texte.txt avec la clé rsa générée précédemment et nomez le fichier résultant TexteC.txt

```bash
rsautl -encrypt -pubin -inkey pub.key -in texte.txt -out texteC.txt

ls -l --block-size=KB
-rwxrwxrwx 1 arsene arsene 1kB Sep 17 16:56 TextLong.txt
-rwxrwxrwx 1 arsene arsene 0kB Sep 17 16:54 Texte.txt
-rwxrwxrwx 1 arsene arsene 1kB Sep 17 17:00 TexteC.txt
-rwxrwxrwx 1 arsene arsene 1kB Sep 17 17:02 TexteLongC.txt
```

### 1.10

Chiffrer TexteLong.txt avec la clé rsa générée précédemment

```bash


ls -l --block-size=KB
-rwxrwxrwx 1 arsene arsene 1kB Sep 17 16:56 TextLong.txt
-rwxrwxrwx 1 arsene arsene 0kB Sep 17 16:54 Texte.txt
-rwxrwxrwx 1 arsene arsene 1kB Sep 17 17:00 TexteC.txt
-rwxrwxrwx 1 arsene arsene 1kB Sep 17 17:11 TexteLongC.txt
```
Cela revient au même en terme de taille de chiffrer en asymétrique et en symétrique.

> La cryptographique asymétrique n'est pas faite pour le chiffrement, plutot pour l'échange de clé. (Message élevé à la puissance un nombre de taille 2048 => sur un long texte c'est trop couteux en mémoire)

## 2. Signature Numérique

### 2.1 

Signer le fichier Texte.txt et vérifier sa taille (TexteS.txt)

```bash
openssl dgst sha1 -out 
openssl rsault -sign -in
```

### 2.2 

Vérifier la signature avec la clé adéquate

```bash
openssl rsautl -verify -inkey publickey.pem -pubin -keyform PEM -in signature
```

### 3. Fonction de hachage

#### 3.1 

Que fait une fonction de hachage, et dans quel but l’utilise-t-on ?

*Une fonction de hachage sert à chiffrer une donnée pour pouvoir ensuite identifier la donnée initiale sans la connaître. C'est utile par exemple pour stocker des mots de passe dans une base de donnée.*

#### 3.2

Hacher `Texte.txt` avec la fonction de votre choix

```bash
openssl dgst -sha512 Texte.txt
```

Chiffrement, signature, hachage dans quel ordre ? 


### 4. Certificats numériques

### 4.1

Quel est le rôle d’un certificat numérique ? Quelle est sa structure?

*Un certificat numérique permet de faire confiance à une clé publique (comme quoi c'est bien celle de la personne à laquelle on veut écrire) en introduisant un tiers de confiance, qui va certifier que la clé publique appartient bien à la personne.*

### 4.2

Saisir le script `get-cert.sh`.
#### 4.3

Quel est le rôle de la commande `s_client` et de la commande `sed` ?

*La commande `s_client` permet de se connecter à un hôte utilisant SSL/TLS.*


*La commande `sed` permet d'extraire une partie du flux texte à partir d'une expression régulière.*

#### 4.4 

Exécuter ce script afin de récupérer lec ertificat d’un site internet de votre choix.

```bash
openssl s_client -connect arsenelapostolet.fr:443 2>&1 | sed -ne '/-BEGIN CERTIFICATE-/,/-END CERTIFICATE-/p'
```

Sous quel formatest le certificat?
*Le certificat est stocké au format texte donc il est au format PEM.*

#### 4.5

Convertir le certificat au format DER

```bash
openssl x509 -outform der -in certificat -out certificat.der
```

Quelle est la différence entre les deux formats ?

*Le format PEM est un format texte (base64)*.
*Le format DER est un format binaire*.
*Les autres formats existants sont PKCS#7 (texte) et PKCS#12 (binaire)*

#### 4.6 

Créer un certificat x509auto signé.

```bash
openssl genrsa -out autosigne.key 4096
openssl req -new -key autosigne.key -out autosigne.pem
```

Sous quel format est le certificat?

*Le certificat est au format PEM.*

### 5. Tester les liaisons SSL

```bash
openssl s_server -key autosigne.key -cert autosigne.csr -accept 44330 -www
```