OPENSSL - une boite à outils cryptograpiques


1 - Présentation de openSSL

1.1 Protocole SSL

Le protocole SSL (Secure Socket Layer) a été développé par la société Netscape Communications Corporation pour permettre aux applications client/serveur de communiquer de façon sécurisée. TLS (Transport Layer Security) est une évolution de SSL réalisée par l’IETF.

La version 3 de SSL est utilisée par tous les navigateurs depuis le début des années 2000.

SSL est un protocole qui s’intercale entre TCP/IP et les applications qui s’appuient sur TCP. Une session SSL se déroule en deux temps

  1. une phase de poignée de mains (handshake) durant laquelle le client et le serveur s’identifient, conviennent du système de chiffrement et d’une clé qu’ils utiliseront par la suite.
  2. la phase de communication proprement dite durant laquelle les données échangées sont compressées, chiffrées et signées.

L’identification durant la poignée de mains est assurée à l’aide de certificats X509.

1.2 openSSL

openSSL est une boîte à outils cryptographiques implémentant les protocoles SSL et TLS qui offre

  1. une bibliothèque de programmation en C permettant de réaliser des applications client/serveur sécurisées s’appuyant sur SSL/TLS.
  2. une commande en ligne (openssl) permettant

Pour connaître toutes les fonctionnalités de openSSL : man openssl.

La syntaxe générale de la commande openssl est

$ openssl <commande> <options>

(le $ est le prompt du shell)

Dans le texte qui suit, les commandes invoquant openssl supposent que cette commande est dans votre PATH.


2 Chiffrement symétrique avec openSSL

C’est la commande enc qui permet de chiffrer/déchiffrer avec openssl :

$ openssl enc <options>

Parmi les options, on doit indiquer le système de chiffrement à choisir dans la liste

        aes-128-cbc        AES 128 bis in CBC mode
        aes-128-ecb        AES 128 bis in ECB mode
        aes-192-cbc        AES 192 bis in CBC mode
        aes-192-ecb        AES 192 bis in ECB mode
        aes-256-cbc        AES 256 bis in CBC mode
        aes-256-ecb        AES 256 bis in ECB mode

        base64             Base 64

        bf-cbc             Blowfish in CBC mode
        bf                 Alias for bf-cbc
        bf-cfb             Blowfish in CFB mode
        bf-ecb             Blowfish in ECB mode
        bf-ofb             Blowfish in OFB mode

        cast-cbc           CAST in CBC mode
        cast               Alias for cast-cbc
        cast5-cbc          CAST5 in CBC mode
        cast5-cfb          CAST5 in CFB mode
        cast5-ecb          CAST5 in ECB mode
        cast5-ofb          CAST5 in OFB mode

        des-cbc            DES in CBC mode
        des                Alias for des-cbc
        des-cfb            DES in CBC mode
        des-ofb            DES in OFB mode
        des-ecb            DES in ECB mode

        des-ede-cbc        Two key triple DES EDE in CBC mode
        des-ede            Alias for des-ede
        des-ede-cfb        Two key triple DES EDE in CFB mode
        des-ede-ofb        Two key triple DES EDE in OFB mode

        des-ede3-cbc       Three key triple DES EDE in CBC mode
        des-ede3           Alias for des-ede3-cbc
        des3               Alias for des-ede3-cbc
        des-ede3-cfb       Three key triple DES EDE CFB mode
        des-ede3-ofb       Three key triple DES EDE in OFB mode

        desx               DESX algorithm.

        idea-cbc           IDEA algorithm in CBC mode
        idea               same as idea-cbc
        idea-cfb           IDEA in CFB mode
        idea-ecb           IDEA in ECB mode
        idea-ofb           IDEA in OFB mode

        rc2-cbc            128 bit RC2 in CBC mode
        rc2                Alias for rc2-cbc
        rc2-cfb            128 bit RC2 in CBC mode
        rc2-ecb            128 bit RC2 in CBC mode
        rc2-ofb            128 bit RC2 in CBC mode
        rc2-64-cbc         64 bit RC2 in CBC mode
        rc2-40-cbc         40 bit RC2 in CBC mode

        rc4                128 bit RC4
        rc4-64             64 bit RC4
        rc4-40             40 bit RC4

        rc5-cbc            RC5 cipher in CBC mode
        rc5                Alias for rc5-cbc
        rc5-cfb            RC5 cipher in CBC mode
        rc5-ecb            RC5 cipher in CBC mode
        rc5-ofb            RC5 cipher in CBC mode

Remarque :

base64 n’est pas un système de chiffrement, mais un codage des fichiers binaires avec 64 caractères ASCII. Ce codage est utilisé en particulier pour la transmission de fichiers binaires par courrier électronique.

2.1 Chiffrement avec mot de passe

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

Vérification

$ diff toto toto.dechiffre

Exercice 1.

Question 1. Chiffrez le fichier de votre choix avec le système de votre choix dans le mode de votre choix, puis déchiffrez-le.

Question 2. Comparez les tailles des fichiers clairs et chiffrés. Donnez une explication sur la différence de ces tailles.

Question 3. Tentez de déchiffrer un cryptogramme en utilisant un mauvais mot de passe. Comment réagit openSSL ?

Exercice 2. Le fichier cryptogramme1 a été chiffré avec le système AES en mode CBC, la clé de 128 bits ayant été obtenue par mot de passe.

Question 1. Le mot de passe codé en base 64 est Q29tVGVzc2U= . À l’aide de la commande openssl appropriée, décodez le mot de passe.

Question 2. Déchiffrez ensuite le cryptogramme1.

2.2 Chiffrement avec clé explicite

Pour chiffrer le fichier toto avec une clé explicite, il faut utiliser les options -K et -iv

L’exemple qui suit montre la commande pour chiffrer toto avec Blowfish en mode CBC avec un vecteur d’initialisation de 64 bits exprimé par 16 chiffres hexa, et une clé de 128 bits exprimée par 32 chiffres hexa.

$ openssl enc -bf-cbc -in toto -out toto.chiffre -iv 0123456789ABCDEF -K 0123456789ABCDEF0123456789ABCDEF

Exercice 3.

Question 1. Chiffrez le fichier clair1 avec le système Blowfish en mode OFB, en utilisant le vecteur d’initialisation (option -iv) et la clé (option -K) de votre choix.

Question 2. Chiffrez le fichier clair correspondant au cryptogramme1 avec le même système, la même clé et le même vecteur d’initialisation que dans la question qui précède.


3 RSA avec openSSL

3.1 Génération d’une paire de clés

On peut générer une paire de clés RSA avec la commande genrsa de openSSL.

$ openssl genrsa -out <fichier> <taille>

fichier est un nom de fichier de sauvegarde de la clé, et taille et la taille souhaitée (exprimée en bits) du modulus de la clé.


Par exemple, pour générer une paire de clés de 1024 bits, stockée dans le fichier maCle.pem, on tape la commande

$ openssl genrsa -out maCle.pem 1024

Le fichier obtenu est un fichier au format PEM (Privacy Enhanced Mail, format en base 64), dont voici un exemple

$ cat maCle.pem
-----BEGIN RSA PRIVATE KEY-----
MIICXAIBAAKBgQCveVjLltevTC5kSAiTYjHMVuAR80DHMLWCp3BOVZ49eXwraXxO
7AfKWpA5g0wFZgZNERIfFYaCnvaQDQA+9BRIfsSSr3oSw0My5SD6eg15v0VmJmvP
d8LgBypJHbr6f5MXWqntvzp0Qvg6ddeNpUIrqkkh4uDfHFDWqyrkQUCvKwIDAQAB
AoGANchUrfnq28DWy0fE0R+cscvC292Z8jN8vrIBWxEk8iSlKU0om6v+a0g8wlP6
3gC6V66uxjY7xxdf7SD+/UykVl4PGFymhLtywSdGlgec3tLgBtV3ytJFilAVDBij
LzQwUegCO4zt1JWYc6vvaVdNyQSaGIIeYGsNDWEYlOtDSlkCQQDVRn9JS15G8p+H
4Z0PbU9ZQg2L1u9/SD/kELVe3Kx1fdHulxH0v8V2AgPdXA29Nhi+TxUtC+V8CMc2
KXmAvFsHAkEA0qBDmjHMDPwcGaqbQ2lymYQIGlZ5TLQFA98Dey2uE+CB6pmS/e/Z
ilu1IaasuE3vBzXfB/JU7DUkV++JQ7TtvQJBAL2s5dUch2sXqlOhjhpDP/eE7CE6
9WLAsbm2Nmd4YJRZYtQLXPfLeeSapC9BCCMHsnfGQ3H9i4mFEQ6VUi7w1Q8CQAQa
pVaS09QI8Y86eM4GdvowzWud9b0d4N8jcFDtIfA3NrDYjzmte8KraMsgEUuCET9F
uHPSL/9uRagE/dq44s0CQCMQU4PMqkMtwzCFsV8ZqLmkDPn1binIAwRLYFcsQRDt
gTi6rycz3Pk1hCVzBfyMd8zwqpwKmR5FoOXuJEv+mVg=
-----END RSA PRIVATE KEY-----

3.2 Visualisation des clés RSA

La commande rsa permet de visualiser le contenu d’un fichier au format PEM contenant une paire de clés RSA.

$ openssl rsa -in <fichier> -text -noout

L’option -text demande l’affichage décodé de la paire de clés. L’option -noout supprime la sortie normalement produite par la commande rsa.


Par exemple

$ openssl rsa -in maCle.pem -text -noout Private-Key: (1024 bit) modulus:
     00:af:79:58:cb:96:d7:af:4c:2e:64:48:08:93:62:
     31:cc:56:e0:11:f3:40:c7:30:b5:82:a7:70:4e:55:
     9e:3d:79:7c:2b:69:7c:4e:ec:07:ca:5a:90:39:83:
     4c:05:66:06:4d:11:12:1f:15:86:82:9e:f6:90:0d:
     00:3e:f4:14:48:7e:c4:92:af:7a:12:c3:43:32:e5:
     20:fa:7a:0d:79:bf:45:66:26:6b:cf:77:c2:e0:07:
     2a:49:1d:ba:fa:7f:93:17:5a:a9:ed:bf:3a:74:42:
     f8:3a:75:d7:8d:a5:42:2b:aa:49:21:e2:e0:df:1c:
     50:d6:ab:2a:e4:41:40:af:2b

publicExponent: 65537 (0x10001)

privateExponent:
     35:c8:54:ad:f9:ea:db:c0:d6:cb:47:c4:d1:1f:9c:
     b1:cb:c2:db:dd:99:f2:33:7c:be:b2:01:5b:11:24:
     f2:24:a5:29:4d:28:9b:ab:fe:6b:48:3c:c2:53:fa:
     de:00:ba:57:ae:ae:c6:36:3b:c7:17:5f:ed:20:fe:
     fd:4c:a4:56:5e:0f:18:5c:a6:84:bb:72:c1:27:46:
     96:07:9c:de:d2:e0:06:d5:77:ca:d2:45:8a:50:15:
     0c:18:a3:2f:34:30:51:e8:02:3b:8c:ed:d4:95:98:
     73:ab:ef:69:57:4d:c9:04:9a:18:82:1e:60:6b:0d:
     0d:61:18:94:eb:43:4a:59

prime1:
     00:d5:46:7f:49:4b:5e:46:f2:9f:87:e1:9d:0f:6d:
     4f:59:42:0d:8b:d6:ef:7f:48:3f:e4:10:b5:5e:dc:
     ac:75:7d:d1:ee:97:11:f4:bf:c5:76:02:03:dd:5c:
     0d:bd:36:18:be:4f:15:2d:0b:e5:7c:08:c7:36:29:
     79:80:bc:5b:07

prime2:
     00:d2:a0:43:9a:31:cc:0c:fc:1c:19:aa:9b:43:69:
     72:99:84:08:1a:56:79:4c:b4:05:03:df:03:7b:2d:
     ae:13:e0:81:ea:99:92:fd:ef:d9:8a:5b:b5:21:a6:
     ac:b8:4d:ef:07:35:df:07:f2:54:ec:35:24:57:ef:
     89:43:b4:ed:bd

exponent1:
     00:bd:ac:e5:d5:1c:87:6b:17:aa:53:a1:8e:1a:43:
     3f:f7:84:ec:21:3a:f5:62:c0:b1:b9:b6:36:67:78:
     60:94:59:62:d4:0b:5c:f7:cb:79:e4:9a:a4:2f:41:
     08:23:07:b2:77:c6:43:71:fd:8b:89:85:11:0e:95:
     52:2e:f0:d5:0f

exponent2:
     04:1a:a5:56:92:d3:d4:08:f1:8f:3a:78:ce:06:76:
     fa:30:cd:6b:9d:f5:bd:1d:e0:df:23:70:50:ed:21:
     f0:37:36:b0:d8:8f:39:ad:7b:c2:ab:68:cb:20:11:
     4b:82:11:3f:45:b8:73:d2:2f:ff:6e:45:a8:04:fd:
     da:b8:e2:cd

coefficient:
     23:10:53:83:cc:aa:43:2d:c3:30:85:b1:5f:19:a8:
     b9:a4:0c:f9:f5:6e:29:c8:03:04:4b:60:57:2c:41:
     10:ed:81:38:ba:af:27:33:dc:f9:35:84:25:73:05:
     fc:8c:77:cc:f0:aa:9c:0a:99:1e:45:a0:e5:ee:24:
     4b:fe:99:58

Les différents éléments de la clé sont affichés en hexadécimal (hormis l’exposant public). On peut distinguer le modulus, l’exposant public qui par défaut est toujours 65537 (openssl n’autorise que deux exposants publics : 65537 (valeur par défaut) ou 3 obtenu avec l’option -3), l’exposant privé, les nombres premiers facteurs du modulus, plus trois autres nombres qui servent à optimiser l’algorithme de déchiffrement.

Exercice 4. Donnez une explication du choix de la valeur 65537 pour exposant public par défaut.

2.3 Chiffrement d’un fichier de clés RSA

Il n’est pas prudent de laisser une paire de clés en clair (surtout la partie privée). Avec la commande rsa, il est possible de chiffrer une paire de clés (Il est possible de chiffrer le fichier lors de sa génération. Il suffit de mettre l’une des trois options -des, -des3, -idea dans la ligne de commande genrsa). Pour cela trois options sont possibles qui précisent l’algorithme de chiffrement symétrique à utiliser : -des, -des3 et -idea.

$ openssl rsa -in maCle.pem -des3 -out maCle.pem writing RSA key
Enter PEM pass phrase:
Verifying - Enter PEM pass phrase:

Une phrase de passe est demandée deux fois pour générer une clé symétrique protégeant l’accès à la clé.

Exercice 5. Avec la commande cat observez le contenu du fichier maCle.pem. Utilisez à nouveau la commande rsa pour visualiser le contenu de la clé.

2.4 Exportation de la partie publique

La partie publique d’une paire de clés RSA est publique, et à ce titre peut être communiquée à n’importe qui. Le fichier maCle.pem contient la partie privée de la clé, et ne peut donc pas être communiqué tel quel (même s’il est chiffré). Avec l’option -pubout on peut exporter la partie publique d’une clé.

$ openssl rsa -in maCle.pem -pubout -out maClePublique.pem

Exercice 6.

Question 1. Notez le contenu du fichier maClePublique.pem. Remarquez les marqueurs de début et de fin.

Question 2. Avec la commande rsa visualisez la clé publique. Attention vous devez préciser l’option -pubin, puisque seule la partie publique figure dans le fichier maClePublique.pem.

2.5 Chiffrement/déchiffrement de données avec RSA

On peut chiffrer des données avec une clé RSA. Pour cela on utilise la commande rsautl

$ openssl rsautl -encrypt -in <fichier_entree> -inkey <cle> -out <fichier_sortie>


Pour déchiffrer on remplace l’option -encrypt par -decrypt. Le fichier contenant la clé doit évidemment contenir la partie privée.

Exercice 7. Chiffrez le fichier de votre choix avec le système symétrique de votre choix. Chiffrez la clé ou le mot de passe utilisé(e) avec la clé publique de votre destinataire (demandez-lui sa clé publique si vous ne l’avez pas). Envoyez-lui le mot de passe chiffré ainsi que le fichier chiffré.


Exercice 8. Il s’agit de déchiffrer le fichier cryptogramme2. Pour cela vous devez récupérer les fichiers suivants (attention la plupart de ces fichiers sont des fichiers binaires)


2.6 Signature de fichiers

Il n’est possible de signer que de petits documents. Pour signer un gros document on calcule d’abord une empreinte de ce document. La commande dgst permet de le faire.

$ openssl dgst <hachage> -out <empreinte> <fichier_entree>

hachage est une fonction de hachage. Avec openssl, plusieurs fonctions de hachage sont proposées dont

Signer un document revient à signer son empreinte. Pour cela, on utilise l’option -sign de la commande rsautl

$ openssl dgst -sign <clef_privee.pem> -keyform PEM -sha256 -binary <fichier_entree> -out <signature>

et pour vérifier la signature

$ openssl dgst -verify <clef_publique.pem> -keyform PEM -signature <signature> -binary <fichier_entree>

il reste ensuite à vérifier que l’empreinte ainsi produite est la même que celle que l’on peut calculer. L’option -pubin indique que la clé utilisée pour la vérification est la partie publique de la clé utilisée pour la signature.

Exercice 9. Signez le fichier de votre choix, puis vérifiez la signature.

Exercice 10. Récupérez l’archive signatures.tar qui contient deux fichiers accompagnés d’une signature

ainsi que la partie publique de la clé RSA ayant produit la signature : key.pub.

De ces deux fichiers, lequel a bien été signé ?