RSA avec openSSL

Classé | Boulot

Posté le 01 avril 2020.

Intégralement et honteusement pompé sur https://www.fil.univ-lille1.fr/~wegrzyno/portail/PAC/Doc/TP-Certificats/tp-certif002.html

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>

où 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

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¹), l’exposant privé, les nombres premiers facteurs du modulus, plus trois autres nombres qui servent à optimiser l’algorithme de déchiffrement.

On vérifie assez facilement avec 2 lignes de java que les 2 nombres premiers p et q font bien 1024 bits et que le modulus n = p x q

Playing with big numbers

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². 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é.

4. Export 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

-----BEGIN PUBLIC KEY----- MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCveVjLltevTC5kSAiTYjHMVuAR 80DHMLWCp3BOVZ49eXwraXxO7AfKWpA5g0wFZgZNERIfFYaCnvaQDQA+9BRIfsSS r3oSw0My5SD6eg15v0VmJmvPd8LgBypJHbr6f5MXWqntvzp0Qvg6ddeNpUIrqkkh 4uDfHFDWqyrkQUCvKwIDAQAB -----END PUBLIC KEY-----

Mais pourquoi ma clé commence toujours par MIGf… ?

# openssl rsa -inform PEM -pubin -in maClePublique.pem -text -noout Public-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 Exponent: 65537 (0x10001)

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

où

fichier_entree est le fichier des données à chiffrer. Attention, le fichier des données à chiffrer ne doit pas avoir une taille excessive (ne doit pas dépasser 116 octets pour une clé de 1024 bits).
cle est le fichier contenant la clé RSA. Si ce fichier ne contient que la parte publique de la clé, il faut rajouter l’option -pubin.
fichier_sortie est le fichier de données chiffré.

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

6. Signature de fichiers

La commande dgst permet de le faire.

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

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

MD5 (option -md5), qui calcule des empreintes de 128 bits,
SHA1 (option -sha1), qui calcule des empreintes de 160 bits,
RIPEMD160 (option -ripemd160), qui calcule des empreintes de 160 bits.

Dans la vraie vie signer un document revient à chiffrer son empreinte (et non pas à signer son empreinte comme on peut le lire dans le doc original, puisque la signature est une double opération cryptographique hash&encrypt). Pour cela, on utilise l’option -sign de la commande rsautl

$ openssl rsautl -sign -in <empreinte> \ -inkey <cle> \ -out <signature>

et pour vérifier la signature

$ openssl rsautl -verify -in <signature> -pubin \ -inkey <cle> -out <empreinte

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.

Pour ceux qui ne veulent pas jouer avec Java : Command Line Utilities openSSL

Si vous voulez faire des tests en ligne (! confidentialité sur clefs privées), il existe de nombreux outils :
– https://8gwifi.org/ – PEM Parseur
– https://www.devglan.com/online-tools/rsa-encryption-decryption
– https://www.sslshopper.com/ssl-certificate-tools.html

Si vous voulez jeter un oeil sur une conf un peu trop provoc’ à mon goût : « Fuck RSA @SummerCon2019 »

Répondre

Cliquez ici pour annuler la réponse.

You must be logged in to post a comment.

Populaire
Derniers
Commentaires
Tags
S'abonner