Découverte d’un certificat

On va se connecter à un site web utilisant https et consulter le certificat électronique. On identifie les différents éléments de ce certificat et on en explique l’utilité.

Vue générale du certificat:

Émis pour :

CN : Nom commun, pour connaître l’URL à identifier (dans notre cas: *.unistra.fr, tous les sous-domaines d’unistra.fr).
O : organisation, le nom de l’organisation à identifier (ex: Université de Strasbourg).
OU: unité d’organisation, pour être un peu plus précis (par exemple « Direction Informatique »).

Émis par :

CN : la même chose, mais pour l’entité de certification.
O : idem.
OU: idem.

Validité: la période de temps pendant laquelle le certificat est valide. Une signature est également ajoutée au certificat.

Requêtes de certification

Pour assurer la sécurité d’une communication, il faut pouvoir être certain qu’une clef publique appartient bien à la personne avec laquelle vous souhaitez communiquer. Pour cela, on utilise des certificats dont le but est de certifier cette association. Dans cette partie, vous allez demander à une autorité de certification d’émettre un certificat pour votre clef publique.

# Génération d'une paire de clefs RSA
openssl genrsa -aes256 -out maCle.pem 4096

L’autorité de certification ne fait que certifier qu’une clef publique est bien la votre. Autrement dit, vous ne lui fournirez pas votre clef privée.

Pour cela, on va créer un fichier nommé maClePublique.pem ne contenant que la partie publique de notre clef RSA.

# Récupération de la partie publique de notre clé
openssl rsa -in maCle.pem -pubout -out maClePublique.pem

Pour solliciter une autorité de certification, vous devez formuler une requête contenant des informations sur vous, en tant que sujet. Le fichier de configuration req.cnf fourni propose des informations par défaut. On va changer notre nom et l’adresse mail dans req.cnf. Ensuite, on va forger une requête de certificat et la stocker dans un fichier nommé maRequete.pem.

# Création d'une requête de certificat
openssl req -new -key maCle.pem -config req.cnf -out maRequete.pem

Voici ce qu’un cat maRequete.pem donne:

Tout est chiffré. C’est une requête à faire signer.

Consulter les informations contenues dans la requête

# Consulter les informations d'une requête
openssl req -in maRequete.pem -text

Il n’y a pas la clé privée qui transite à travers le net, mais il y a la clé publique dedans.

Certificate Request:
Data:
    Version: 0 (0x0)
    Subject: C=FR, ST=Alsace, L=Strasbourg, O=Universite de Strasbourg, OU=M1RISE, CN=Philippe/emailAddress=philippe.pittoli@etu.unistra.fr
    Subject Public Key Info:
        Public Key Algorithm: rsaEncryption
            Public-Key: (1024 bit)
            Modulus:
                00:97:e6:bc:4c:f9:3e:b9:c8:7b:aa:dd:bd:3e:70:
                23:8c:6f:75:8d:18:2e:4b:3a:6d:f3:a2:5b:58:42:
                26:c0:ec:00:25:bd:07:23:f0:72:5d:38:72:19:22:
                d7:78:c2:29:a9:91:3d:3e:91:5b:31:82:21:77:97:
                f7:74:d0:97:c1:88:08:b0:ae:45:89:99:b5:cf:f8:
                dc:ef:66:64:ff:b8:08:3b:da:24:6a:04:74:5e:5a:
                80:eb:33:1f:26:4a:a2:31:f5:c6:f5:b7:2d:ef:59:
                99:48:56:c7:a5:32:15:95:99:12:55:f6:c4:7e:79:
                bf:e8:54:2a:27:96:28:c0:57
            Exponent: 65537 (0x10001)
    Attributes:
        a0:00
Signature Algorithm: sha1WithRSAEncryption
     42:a3:b8:16:c2:f0:49:1d:dc:03:41:24:9d:d6:45:05:a7:ff:
     48:15:27:0a:a0:32:64:f1:ac:78:2b:58:aa:e9:83:45:16:d0:
     a9:95:3e:c5:d1:01:c0:1e:7e:34:c6:81:3b:fe:56:7c:56:c5:
     2c:31:42:e9:b7:a5:79:5c:1b:26:49:bf:0a:ee:fe:a6:44:b1:
     76:98:b8:95:1c:3e:f7:f9:6b:d2:78:66:d7:bb:4b:60:7b:94:
     1b:5c:fc:79:b6:de:d4:70:6a:3d:90:79:18:52:23:e7:47:77:
     2b:c7:fd:e2:29:9e:61:f9:1b:6f:15:66:5a:ac:29:e9:4c:36:
     55:f1
-----BEGIN CERTIFICATE REQUEST-----
MIIB6zCCAVQCAQAwgaoxCzAJBgNVBAYTAkZSMQ8wDQYDVQQIEwZBbHNhY2UxEzAR
BgNVBAcTClN0cmFzYm91cmcxITAfBgNVBAoTGFVuaXZlcnNpdGUgZGUgU3RyYXNi
b3VyZzEPMA0GA1UECxMGTTFSSVNFMREwDwYDVQQDEwhQaGlsaXBwZTEuMCwGCSqG
SIb3DQEJARYfcGhpbGlwcGUucGl0dG9saUBldHUudW5pc3RyYS5mcjCBnzANBgkq
hkiG9w0BAQEFAAOBjQAwgYkCgYEAl+a8TPk+uch7qt29PnAjjG91jRguSzpt86Jb
WEImwOwAJb0HI/ByXThyGSLXeMIpqZE9PpFbMYIhd5f3dNCXwYgIsK5FiZm1z/jc
72Zk/7gIO9okagR0XlqA6zMfJkqiMfXG9bct71mZSFbHpTIVlZkSVfbEfnm/6FQq
J5YowFcCAwEAAaAAMA0GCSqGSIb3DQEBBQUAA4GBAEKjuBbC8Ekd3ANBJJ3WRQWn
/0gVJwqgMmTxrHgrWKrpg0UW0KmVPsXRAcAefjTGgTv+VnxWxSwxQum3pXlcGyZJ
vwru/qZEsXaYuJUcPvf5a9J4Zte7S2B7lBtc/Hm23tRwaj2QeRhSI+dHdyvH/eIp
nmH5G28VZlqsKelMNlXx
-----END CERTIFICATE REQUEST-----

Visualiser le contenu d’un certificat :

Un certificat produit par openssl est un fichier au format PEM.

Voici ce qu’un cat unCertif.pem donne:

-----BEGIN CERTIFICATE-----
....
-----END CERTIFICATE-----

# Contenu d'un certificat
openssl x509 -in unCertif.pem -text -noout

On peut voir la validité du certificat d’autorité et la taille de sa clef:

Not Before: Jan 31 14:30:53 2013 GMT
Not After : Jan 29 14:30:53 2023 GMT
Durée de validité : ~10 ans.
Taille de la clé : 2048 bits.

Du côté de l’autorité de certification, la requête maRequete.pem a été reçue. On peut simuler ce comportement en utilisant la requête de de notre voisin et inversement. À partir de cette requête, on va (en tant qu’autorité) forger un certificat et le signer. Pour commencer, l’autorité attribue un numéro de série et une période de validité à chaque certificat créé.

Création d’une autorité de certification

Un certificat d’autorité de certification est tout simplement la clé publique de l’autorité associée aux informations de l’autorité en tant que sujet. Vous pouvez créer une clé et la certifier par vous même, et obtenir donc un certificat d’autorité, sans passer par la génération d’une requête à une autorité.

Générez les clefs de l’autorité de certification.

# Création d'une autorité de certificat
openssl genrsa -aes256 -out ca.key.pem 4096

Génération d’un certificat pour l’autorité de certification.

# Génération du certificat pour l'AC
openssl req -new -key ca.key.pem -out ca.csr
openssl x509 -req -in ca.csr -signkey ca.key.pem -out ca.cert.pem

Il faut révoquer l’ancien certificat et faire une nouvelle requête. Il faut changer la clé régulièrement (par exemple une fois par an) afin d’être sûr que personne n’ait le temps de la casser.

Lien intéressant, une sorte de petit récapitulatif. Génération d’un certificat —

Il faut qu’il soit de 10 jours de validité et 123 comme numéro de série pour notre requête et on le nomme testcertif.pem.

# Génération d'un certificat
openssl x509 -req -days 10 -set\_serial 123 -in maRequete.pem \
    -CA ca.cert.pem \
    -CAkey ca.key.pem \
    -out testcertif.cert

Nous pouvons aussi vérifier le certificat de quelqu’un d’autre. Par exemple, on peut créer un certificat pour la clef publique de notre voisin saRequete.pem et le nommer sonCertif.cert.pem puis lui renvoyer, ceritifé par notre autorité.

# Certificat pour la clé publique du voisin
openssl x509 -req -days 10 -set\_serial 124 -in saRequete.pem \
    -CA ca.cert.pem \
    -CAkey ca.key.pem \
    -out sonCertif.cert.pem

Une fois qu’on reçoit notre certificat, on le sauvegarde le sous le nom monCertif.pem. Le voisin peut vérifier la validité du certificat reçu avec la commande verify. Pour vérifier la validité d’un certificat, il est nécessaire de disposer du certificat de l’autorité qui l’a émis.

# Vérification du certificat
openssl verify -CAfile ca.cert.pem monCertif.pem
    monCertif.pem: OK

Utilisation de certificats

On va utiliser notre certificat pour :

signer,
vérifier la signature,
chiffrer et déchiffrer des messages.

Lorsqu’on dispose d’une paire de clefs (publique, privée), et d’un certificat qui les accompagne, attestant de notre adresse électronique, il est possible, entre autres choses, de signer nos mails, et de recevoir des mails chiffrés de la part de nos correspondants qui disposent de notre certificat.

Remarque : lorsqu’on chiffre un courrier électronique, il faut s’assurer que le logiciel du destinataire est en mesure de le déchiffrer. C’est pour quoi le texte chiffré doit être pour l’instant envoyé en pièce jointe à notre voisin. Pour signer un texte ou un courrier, on utilisera notre certificat monCertif.pem et notre clef privée maCle.pem.

Forger un courrier signé

On va forger un courrier signé ayant comme sujet « courrier signé » dont le contenu est dans un fichier Montext.txt. On sera l’expéditeur du courrier, et le destinataire sera notre voisin. On redirigera la sortie de la commande précédente vers un fichier Montext-sign.txt.

# Forger un courrier signé
openssl smime -sign -in Montext.txt -inkey maCle.pem \
    -out Montext-sign.txt \
    -from "<philippe.pittoli@etu.unistra.fr>" \
    -to "<philippe.pittoli@etu.unistra.fr>" \
    -signer monCertif.pem \
    -subject "mail signé"

On récupère le texte signé par votre voisin sous le nom Sontext-sign.txt. Lorsqu’on reçoit un tel texte signé, il faut le contenu signé et le certificat de l’autorité de certification pour vérifier la signature.

# Vérification d'une signature
openssl smime -verify -CAfile ca.cert.pem -in Montext-sign.txt 
    Ceci est mon texte.
    Verification successful

Chiffrement et déchiffrement de messages

Pour envoyer un texte chiffré à un destinataire, de quoi devez-vous disposer ? Quelle commande invoquer ?

On a besoin du texte à chiffrer et de la clé publique du destinataire (qui est dans le certificat). On redirigera la sortie de la commande vers un fichier Montext-enc.txt.

# Chiffrement du message
openssl smime -encrypt -in Montext.txt -text -aes256 \
    -out Montext-enc.txt monCertif.pem

Une fois le texte chiffré reçu, le destinataire doit le déchiffrer. Il a besoin du texte à déchiffrer et de sa clé privée.

# Déchiffrement du message
openssl smime -decrypt -in Montext-enc.txt -inkey maCle.pem
    Enter pass phrase for maCle.pem:
    Content-Type: text/plain
    Ceci est mon texte.

Utilisation de certificats avec Mozilla/Thunderbird

La première chose à faire pour pouvoir échanger des courriers signés et/ou chiffrés avec Mozilla est d’importer notre certificat et notre clef privée dans la base de données de certificats gérés par notre navigateur.

Edition/Preferences : consulter la base de données des certificats de notre client de messagerie.

Il faut distinguer nos certificats de ceux de tiers et de serveurs sécurisés déjà consultés.

Préférences → Advancé → Certificats → Voir les certificats.

onglet Personnes : certificats de tiers, certifiés par des CA
onglet Serveurs : autorités de certification connus

Consultez les certificats des autorités de certification que vous connaissez. Pour consulter les certificats des autorités de certificatoin qu’on connait, l’interface est quasiment la même que lors de la consultation des certificats sur Mozilla Firefox. On peut avoir une liste assez longue de certificats alors on ne va pas tous les analyser ici, mais voici l’exemple de DigiCert.

# Première étape : export du certificat d DigiCert dans le navigateur
# Analyse d'un certificat d'autorité de certification
openssl x509 -in DigiCertGlobalRootCA -text -noout

Certificate:
    Data:
        Version: 3 (0x2)
        Serial Number:
            08:3b:e0:56:90:42:46:b1:a1:75:6a:c9:59:91:c7:4a
    Signature Algorithm: sha1WithRSAEncryption
        Issuer: C=US, O=DigiCert Inc, OU=www.digicert.com, CN=DigiCert Global Root CA
        Validity
            Not Before: Nov 10 00:00:00 2006 GMT
            Not After : Nov 10 00:00:00 2031 GMT
        Subject: C=US, O=DigiCert Inc, OU=www.digicert.com, CN=DigiCert Global Root CA
        Subject Public Key Info:
            Public Key Algorithm: rsaEncryption
                Public-Key: (2048 bit)
                Modulus:
                    00:e2:3b:e1:11:72:de:a8:a4:d3:a3:57:aa:50:a2:
                    8f:0b:77:90:c9:a2:a5:ee:12:ce:96:5b:01:09:20:
                    cc:01:93:a7:4e:30:b7:53:f7:43:c4:69:00:57:9d:
                    e2:8d:22:dd:87:06:40:00:81:09:ce:ce:1b:83:bf:
                    df:cd:3b:71:46:e2:d6:66:c7:05:b3:76:27:16:8f:
                    7b:9e:1e:95:7d:ee:b7:48:a3:08:da:d6:af:7a:0c:
                    39:06:65:7f:4a:5d:1f:bc:17:f8:ab:be:ee:28:d7:
                    74:7f:7a:78:99:59:85:68:6e:5c:23:32:4b:bf:4e:
                    c0:e8:5a:6d:e3:70:bf:77:10:bf:fc:01:f6:85:d9:
                    a8:44:10:58:32:a9:75:18:d5:d1:a2:be:47:e2:27:
                    6a:f4:9a:33:f8:49:08:60:8b:d4:5f:b4:3a:84:bf:
                    a1:aa:4a:4c:7d:3e:cf:4f:5f:6c:76:5e:a0:4b:37:
                    91:9e:dc:22:e6:6d:ce:14:1a:8e:6a:cb:fe:cd:b3:
                    14:64:17:c7:5b:29:9e:32:bf:f2:ee:fa:d3:0b:42:
                    d4:ab:b7:41:32:da:0c:d4:ef:f8:81:d5:bb:8d:58:
                    3f:b5:1b:e8:49:28:a2:70:da:31:04:dd:f7:b2:16:
                    f2:4c:0a:4e:07:a8:ed:4a:3d:5e:b5:7f:a3:90:c3:
                    af:27
                Exponent: 65537 (0x10001)
        X509v3 extensions:
            X509v3 Key Usage: critical
                Digital Signature, Certificate Sign, CRL Sign
            X509v3 Basic Constraints: critical
                CA:TRUE
            X509v3 Subject Key Identifier: 
                03:DE:50:35:56:D1:4C:BB:66:F0:A3:E2:1B:1B:C3:97:B2:3D:D1:55
            X509v3 Authority Key Identifier: 
                keyid:03:DE:50:35:56:D1:4C:BB:66:F0:A3:E2:1B:1B:C3:97:B2:3D:D1:55

    Signature Algorithm: sha1WithRSAEncryption
         cb:9c:37:aa:48:13:12:0a:fa:dd:44:9c:4f:52:b0:f4:df:ae:
         04:f5:79:79:08:a3:24:18:fc:4b:2b:84:c0:2d:b9:d5:c7:fe:
         f4:c1:1f:58:cb:b8:6d:9c:7a:74:e7:98:29:ab:11:b5:e3:70:
         a0:a1:cd:4c:88:99:93:8c:91:70:e2:ab:0f:1c:be:93:a9:ff:
         63:d5:e4:07:60:d3:a3:bf:9d:5b:09:f1:d5:8e:e3:53:f4:8e:
         63:fa:3f:a7:db:b4:66:df:62:66:d6:d1:6e:41:8d:f2:2d:b5:
         ea:77:4a:9f:9d:58:e2:2b:59:c0:40:23:ed:2d:28:82:45:3e:
         79:54:92:26:98:e0:80:48:a8:37:ef:f0:d6:79:60:16:de:ac:
         e8:0e:cd:6e:ac:44:17:38:2f:49:da:e1:45:3e:2a:b9:36:53:
         cf:3a:50:06:f7:2e:e8:c4:57:49:6c:61:21:18:d5:04:ad:78:
         3c:2c:3a:80:6b:a7:eb:af:15:14:e9:d8:89:c1:b9:38:6c:e2:
         91:6c:8a:ff:64:b9:77:25:57:30:c0:1b:24:a3:e1:dc:e9:df:
         47:7c:b5:b4:24:08:05:30:ec:2d:bd:0b:bf:45:bf:50:b9:a9:
         f3:eb:98:01:12:ad:c8:88:c6:98:34:5f:8d:0a:3c:c6:e9:d5:
         95:95:6d:de

Pour importer un certificat dans la base de données, il faut créer d’abord une enveloppe PKCS#12. Il s’agit d’une norme de fichier adoptée pour « ficeler » ensemble un ou plusieurs certificats et clefs.

Création d’une enveloppe PKCS#12

Cela se fait avec notre certificat, le certificat de l’autorité l’ayant signée et notre clef privée.

# Création d'une enveloppe PKCS#12
openssl pkcs12 -export -in monCertif.pem -inkey maCle.pem \
    -certfile ca.cert.pem \
    -out mon_enveloppe.p12

On va l’importer dans la base de données de certificats de notre navigateur, et vérifier que notre certificat figure maintenant dans la liste. Vos certificats → importer. Puis on entre le mot de passe.

Si on demande à le visualiser, on peut voir qu’il n’est pas possible de le vérifier car l’émetteur n’est pas digne de confiance.

Faire accepter une autorité de certification

Pour que l’autorité Père Ubu soit accepté dans notre navigateur, il faut éditer son certificat (cf. liste des certificats d’autorités signataires).

Onglet « Autorités », on choisit « Royaume de Pologne » -> « Pere Ubu », on sélectionne « Modifier la confiance » et on donne les bons droits (l’autoriser à identifier des utilisateurs de courrier électronique).

On vérifie notre certificat et on envoie un courrier signé à notre voisin. Pour ça, on sélectionne le smime « Signer numériquement ce message », comme c’est la première fois qu’on fait ça, on sélectionne le certificat avec lequel on va pouvoir signer le message.

Pour chiffrer, on sélectionne « Chiffrer ce message » (quoi de plus simple ? ;) ).

Karchnu {Computer science, Anarchy, Cats}