- À propos des certificats numériques en cybersécurité
- Cryptographie asymétrique et identité à clé publique
- Structure et contenu d'un certificat X.509
- Autorités de certification et infrastructure PKI
- Cycle de vie et validation des certificats numériques
- Certificats numériques, HTTPS et authentification TLS
- Signatures numériques et applications des certificats
- Vulnérabilités, risques et bonnes pratiques de sécurité
- Pratique des certificats numériques avec Python
- À retenir
Un certificat numérique, appelé Digital Certificate en anglais, est un document électronique structuré qui associe une clé publique à une identité ou à une entité déterminée. Cette association peut être attestée par une autorité de certification au moyen d'une signature cryptographique. Les certificats numériques occupent une place fondamentale dans la cybersécurité moderne : ils interviennent dans les connexions HTTPS, les signatures électroniques, l'authentification des utilisateurs et des machines, la protection des communications et la gestion des identités numériques.
La sécurité d'un certificat ne repose pas simplement sur les informations qu'il contient. Elle dépend également de la protection de la clé privée correspondante, de la fiabilité de l'autorité qui l'a délivré, de la validité de sa chaîne de certification et de la vérification correcte de son identité par les applications. Ce tutoriel présente ces différents mécanismes, depuis les fondements mathématiques jusqu'à leur mise en œuvre avec le langage Python.
1. À propos des certificats numériques en cybersécurité
Définition d'un certificat numérique
Un certificat numérique est un ensemble de données normalisées permettant d'associer une clé publique à une identité, un nom de domaine, une organisation ou un autre type d'entité. Dans le cas des certificats X.509, cette association est généralement authentifiée par une signature numérique produite par une autorité émettrice.
Lorsqu'un navigateur visite un site HTTPS, le serveur présente un certificat contenant notamment sa clé publique et les noms de domaine pour lesquels il est valable. Le navigateur vérifie alors plusieurs propriétés du certificat avant d'établir une connexion considérée comme authentifiée.
Pourquoi les certificats numériques sont-ils nécessaires ?
La cryptographie asymétrique permet à deux entités d'utiliser des clés publiques et privées pour réaliser des opérations cryptographiques. Cependant, connaître une clé publique ne permet pas automatiquement de savoir à qui elle appartient.
Un attaquant pourrait présenter sa propre clé publique en prétendant qu'elle appartient à un serveur légitime. Le certificat numérique répond à ce problème en fournissant une association vérifiable entre une identité et une clé publique.
Cette association constitue l'un des fondements de la confiance numérique.
Certificat numérique et identité numérique
L'identité numérique représente les informations utilisées pour identifier une entité dans un environnement informatique. Cette entité peut être une personne, une organisation, un serveur, un appareil ou un service.
Un certificat peut contenir certaines informations d'identité, mais leur portée dépend de la politique de délivrance. Par exemple, un certificat TLS de validation de domaine atteste principalement qu'un contrôle du domaine a été effectué au moment de sa délivrance. Il ne constitue pas une garantie générale sur l'honnêteté du propriétaire du site.
Certificat numérique et clé publique
La clé publique contenue dans le certificat est destinée à être communiquée aux systèmes qui souhaitent vérifier certaines opérations cryptographiques ou établir des communications sécurisées.
La clé privée correspondante doit, en revanche, rester sous le contrôle de son propriétaire. Elle ne figure pas dans le certificat.
Certificat numérique et signature numérique
Une signature numérique permet de vérifier qu'un ensemble de données n'a pas été modifié depuis sa signature et que la signature a été produite avec la clé privée correspondant à une clé publique donnée.
Une autorité de certification signe les données du certificat avec sa propre clé privée. Un système qui connaît et accepte la clé publique de cette autorité peut vérifier la signature du certificat.
Différence entre certificat numérique et mot de passe
Un mot de passe est un secret utilisé dans un mécanisme d'authentification. Un certificat numérique, lui, est généralement une information publique qui associe une identité à une clé publique.
Dans une authentification par certificat, la preuve de possession de la clé privée correspondante est essentielle. La simple présentation d'un certificat public ne suffit pas à démontrer cette possession.
Principaux objectifs des certificats numériques
- Authentification : vérifier l'identité d'un serveur, d'un utilisateur ou d'une machine selon les règles applicables.
- Intégrité : permettre la vérification de signatures numériques.
- Confidentialité : contribuer à l'établissement de communications chiffrées.
- Gestion de confiance : organiser les relations entre entités et autorités de certification.
- Contrôle d'accès : participer à des mécanismes d'autorisation fondés sur des identités certifiées.
- Traçabilité : faciliter l'association d'opérations cryptographiques à des identités, sous réserve de la sécurité des clés et des procédures.
2. Cryptographie asymétrique et identité à clé publique
Principe de la cryptographie asymétrique
La cryptographie asymétrique utilise une paire de clés mathématiquement liées. La première est appelée clé publique et la seconde clé privée.
La clé publique peut être distribuée librement, tandis que la clé privée doit rester secrète. Selon l'algorithme employé, ces clés permettent notamment de vérifier des signatures, de réaliser certaines opérations de chiffrement ou de participer à un échange de clés.
Clé privée
La clé privée est un élément sensible dont la divulgation peut compromettre l'identité cryptographique de son propriétaire. Lorsqu'elle sert à signer des données, toute personne qui parvient à l'obtenir peut potentiellement produire des signatures apparaissant comme celles du titulaire légitime.
Elle doit donc être protégée par des permissions adaptées, un stockage sécurisé et, lorsque le niveau de sécurité l'exige, par un dispositif matériel spécialisé.
Clé publique
La clé publique permet notamment de vérifier les signatures produites par la clé privée correspondante. Elle peut être incluse dans un certificat et distribuée aux systèmes qui doivent vérifier l'identité cryptographique d'une entité.
La difficulté n'est pas seulement de recevoir cette clé : il faut également s'assurer qu'elle appartient effectivement à l'entité annoncée.
Algorithme RSA
RSA est un algorithme de cryptographie asymétrique reposant sur des propriétés mathématiques liées notamment à la factorisation de grands entiers.
Il peut être utilisé pour les signatures numériques et certains mécanismes de chiffrement. Dans les applications modernes, les signatures RSA utilisent généralement des schémas sécurisés tels que RSA-PSS ou, dans de nombreux environnements compatibles, PKCS#1 v1.5.
Cryptographie sur les courbes elliptiques
La Elliptic Curve Cryptography, ou ECC, utilise des propriétés algébriques des courbes elliptiques définies sur des corps finis.
Elle permet d'obtenir des niveaux de sécurité élevés avec des clés généralement plus courtes que celles de RSA pour des niveaux de sécurité comparables.
ECDSA
ECDSA est un algorithme de signature numérique fondé sur la cryptographie des courbes elliptiques. Il permet de signer des données avec une clé privée et de vérifier la signature avec la clé publique correspondante.
Ed25519
Ed25519 est un algorithme moderne de signature numérique basé sur une construction utilisant une courbe elliptique. Il est apprécié pour ses performances et ses propriétés de sécurité lorsqu'il est correctement implémenté.
Fonctions de hachage
Une fonction de hachage cryptographique transforme des données de longueur variable en une empreinte de longueur fixe. Une bonne fonction cryptographique doit notamment rendre difficile la recherche de collisions.
Des fonctions comme SHA-256 sont utilisées dans de nombreux mécanismes de signature et de vérification d'intégrité.
Pourquoi une clé publique ne suffit-elle pas ?
Supposons qu'un utilisateur souhaite se connecter au site www.example.com. Un tiers malveillant pourrait lui transmettre une clé publique différente en affirmant qu'elle appartient au serveur recherché.
Sans mécanisme de certification ou de vérification indépendante, l'utilisateur ne dispose pas d'une preuve suffisante pour associer cette clé au véritable serveur.
Le certificat numérique permet de construire une association contrôlable entre la clé et le nom de domaine, à condition que la chaîne de confiance et les autres vérifications soient correctement réalisées.
3. Structure et contenu d'un certificat X.509
Présentation de la norme X.509
La norme X.509 définit un format de certificat largement utilisé dans les infrastructures à clés publiques. Les certificats X.509 sont employés notamment pour TLS, l'authentification de clients, la signature de logiciels et certains systèmes de messagerie sécurisée.
Un certificat X.509 contient une structure normalisée, des extensions éventuelles et une signature numérique.
Version du certificat
Le champ Version indique la version de la structure X.509 utilisée. La version 3 est particulièrement importante parce qu'elle permet d'inclure des extensions définissant notamment les usages autorisés et les identités supplémentaires.
Numéro de série
Le Serial Number est un identifiant attribué par l'autorité émettrice. Il permet de distinguer les certificats émis par une même autorité.
Il joue également un rôle dans certains mécanismes de révocation, qui identifient les certificats à l'aide de leur numéro de série et de leur autorité émettrice.
Émetteur du certificat
Le champ Issuer identifie l'entité qui a émis le certificat. Dans une infrastructure classique, il s'agit d'une autorité de certification.
Le nom de l'émetteur ne suffit pas à prouver l'authenticité du certificat : sa signature doit être vérifiée avec une clé publique appropriée.
Sujet du certificat
Le champ Subject décrit l'entité à laquelle le certificat est associé. Il peut contenir un nom d'organisation, un nom commun ou d'autres attributs.
Pour les certificats TLS modernes, la vérification des noms de domaine repose principalement sur l'extension Subject Alternative Name, et non sur le seul champ Common Name.
Période de validité
Un certificat contient une date de début de validité, appelée Not Before, et une date de fin de validité, appelée Not After.
Un certificat utilisé en dehors de cette période doit normalement être rejeté lors d'une validation appropriée. La validité temporelle n'est cependant qu'une condition parmi d'autres.
Subject Public Key Info
Le champ Subject Public Key Info contient la clé publique du sujet et des informations sur l'algorithme associé.
Il permet aux applications d'obtenir les données nécessaires pour vérifier des signatures ou effectuer d'autres opérations compatibles avec cette clé.
Subject Alternative Name
L'extension Subject Alternative Name, abrégée SAN, peut contenir plusieurs noms de domaine, adresses IP ou autres identifiants.
Par exemple, un certificat destiné à un serveur Web peut couvrir www.example.com et example.com, si ces noms sont explicitement indiqués.
Key Usage
L'extension Key Usage précise les opérations cryptographiques autorisées pour la clé associée au certificat.
Elle peut notamment indiquer que la clé est destinée à la signature numérique ou à certaines opérations de certification.
Extended Key Usage
L'extension Extended Key Usage, ou EKU, précise des usages applicatifs particuliers, comme l'authentification d'un serveur TLS ou d'un client TLS.
Les applications doivent tenir compte de ces restrictions lorsqu'elles vérifient un certificat.
Basic Constraints
L'extension Basic Constraints indique notamment si un certificat peut être utilisé comme certificat d'autorité de certification.
Cette distinction est fondamentale pour empêcher qu'un certificat ordinaire de serveur soit utilisé comme autorité émettrice.
Signature du certificat
Le certificat comporte une signature cryptographique produite par l'émetteur sur les données du certificat.
La vérification de cette signature permet de détecter une modification des données signées, mais elle doit être associée à une vérification de la confiance accordée à l'émetteur.
Tableau récapitulatif des champs X.509
| Champ | Rôle |
|---|---|
| Version | Version du format X.509. |
| Serial Number | Identifiant du certificat chez l'émetteur. |
| Issuer | Identité de l'autorité émettrice. |
| Subject | Informations sur l'entité certifiée. |
| Not Before | Début de validité. |
| Not After | Fin de validité. |
| Public Key | Clé publique du sujet. |
| SAN | Identités et noms supplémentaires. |
| Key Usage | Usages cryptographiques autorisés. |
| Extended Key Usage | Usages applicatifs autorisés. |
| Basic Constraints | Rôle éventuel d'autorité de certification. |
| Signature | Authentification cryptographique des données du certificat. |
4. Autorités de certification et infrastructure PKI
Définition d'une autorité de certification
Une autorité de certification, ou Certificate Authority (CA), est une entité chargée de délivrer des certificats numériques selon une politique de certification définie.
Elle doit notamment vérifier les éléments requis pour la délivrance du certificat et protéger les clés privées utilisées pour signer les certificats émis.
Infrastructure à clés publiques
Une Public Key Infrastructure, ou PKI, regroupe les composants techniques, les procédures et les règles permettant de gérer des certificats et des clés publiques.
Une PKI peut comprendre des autorités de certification, des systèmes d'enregistrement, des mécanismes de publication, des services de révocation et des politiques de sécurité.
Autorité racine
Une Root CA est une autorité située au sommet d'une hiérarchie de certification. Son certificat est généralement auto-signé et peut être installé comme ancre de confiance dans un système.
La confiance accordée à cette autorité ne résulte pas simplement de son auto-signature. Elle provient de son inclusion dans un magasin de confiance ou d'une configuration explicite de l'administrateur.
Autorité intermédiaire
Une Intermediate CA est une autorité dont le certificat a été délivré par une autre autorité.
L'utilisation d'autorités intermédiaires permet de séparer les fonctions de certification et de limiter l'exposition opérationnelle de la clé privée de l'autorité racine.
Autorité d'enregistrement
Une Registration Authority, ou RA, peut être chargée de certaines opérations de vérification des demandes avant leur transmission à l'autorité de certification.
Elle intervient selon l'organisation et les politiques de la PKI concernée.
Chaîne de certification
Une chaîne de certification relie un certificat final à une ancre de confiance au moyen de certificats intermédiaires.
Pour être acceptée, cette chaîne doit satisfaire plusieurs contrôles : signatures, périodes de validité, contraintes d'autorité, usages autorisés, politiques applicables et éventuellement statut de révocation.
Exemple de chaîne de confiance
- Une autorité racine est reconnue comme ancre de confiance.
- Elle délivre un certificat à une autorité intermédiaire.
- L'autorité intermédiaire délivre un certificat à un serveur.
- Le serveur présente son certificat au client.
- Le client construit et vérifie une chaîne appropriée.
- Le client vérifie également que le certificat correspond au serveur demandé.
Certificats auto-signés
Un certificat auto-signé est un certificat dont la signature est produite avec la clé privée correspondant à sa propre clé publique.
Les certificats auto-signés peuvent être utiles dans des laboratoires, des environnements internes ou comme certificats racines. Toutefois, ils ne sont pas automatiquement reconnus comme fiables par les navigateurs.
Validation de domaine
Un certificat Domain Validation, ou DV, est délivré après vérification du contrôle d'un nom de domaine selon une méthode acceptée par l'autorité.
Il ne prouve pas, à lui seul, l'identité juridique ou la fiabilité commerciale de l'organisation exploitant le site.
Validation d'organisation
Un certificat Organization Validation, ou OV, implique des vérifications supplémentaires concernant l'organisation selon les règles applicables.
Validation étendue
Un certificat Extended Validation, ou EV, implique des procédures de vérification organisationnelle plus approfondies. Il n'utilise pas un chiffrement intrinsèquement plus fort qu'un certificat DV équivalent.
Let's Encrypt
Let's Encrypt est une autorité de certification publique proposant notamment l'émission automatisée de certificats TLS de validation de domaine.
Elle utilise le protocole ACME pour automatiser des opérations comme la validation du domaine et la gestion des certificats.
5. Cycle de vie et validation des certificats numériques
Génération de la paire de clés
Le cycle de vie d'un certificat commence généralement par la création d'une paire de clés cryptographiques. La clé privée doit être conservée dans un environnement sécurisé, tandis que la clé publique pourra être intégrée à une demande de certification.
Dans certains environnements, les clés sont générées directement dans un HSM, une carte à puce ou un autre composant matériel sécurisé.
Demande de signature de certificat
Une Certificate Signing Request, ou CSR, contient notamment la clé publique et certaines informations relatives au demandeur.
Elle est généralement signée avec la clé privée correspondante, ce qui permet de démontrer la possession de cette clé au moment de la demande.
Vérification du demandeur
L'autorité de certification vérifie les éléments nécessaires selon le type de certificat demandé. Pour un certificat TLS DV, cette étape concerne principalement le contrôle du domaine.
Les certificats d'organisation ou d'identité personnelle peuvent nécessiter d'autres vérifications.
Émission du certificat
Après validation, l'autorité construit le certificat et le signe avec sa clé privée d'émission. Le certificat peut ensuite être installé sur un serveur, une application ou un dispositif d'authentification.
Déploiement du certificat
Le déploiement consiste à configurer le système pour présenter le certificat approprié et utiliser la clé privée correspondante.
Une configuration incorrecte peut provoquer des erreurs de connexion, des avertissements de sécurité ou l'exposition de secrets.
Renouvellement
Les certificats possèdent une durée de validité limitée. Le renouvellement consiste à obtenir un nouveau certificat avant l'expiration de l'ancien.
L'automatisation réduit les risques d'interruption de service dus à un certificat expiré. Le renouvellement peut également être l'occasion de remplacer la paire de clés.
Révocation
La révocation permet de déclarer qu'un certificat ne doit plus être considéré comme valide avant sa date normale d'expiration.
Elle peut être nécessaire lorsque la clé privée est compromise, lorsqu'un certificat a été délivré incorrectement ou lorsqu'une identité certifiée n'est plus autorisée.
Certificate Revocation List
Une Certificate Revocation List, ou CRL, est une liste signée de certificats révoqués publiée par une autorité compétente.
Les systèmes qui l'utilisent doivent vérifier son authenticité et sa fraîcheur.
Online Certificate Status Protocol
Le protocole OCSP permet d'obtenir des informations sur le statut de révocation d'un certificat.
Son utilisation dépend de l'application, de la politique de validation et de la disponibilité des services concernés. Toutes les applications ne vérifient pas systématiquement la révocation de la même manière.
Certificate Transparency
La Certificate Transparency, ou CT, repose sur des journaux permettant de rendre visibles les certificats TLS publics enregistrés.
Elle facilite notamment la détection de certificats inattendus ou délivrés de manière incorrecte pour un domaine.
Étapes d'une validation correcte
- Analyser la structure du certificat.
- Vérifier sa période de validité.
- Construire une chaîne vers une ancre de confiance autorisée.
- Vérifier les signatures cryptographiques de la chaîne.
- Contrôler les extensions et les usages autorisés.
- Vérifier l'identité attendue, notamment le nom de domaine pour TLS.
- Appliquer les politiques de révocation pertinentes.
- Rejeter le certificat lorsqu'une condition de validation obligatoire échoue.
6. Certificats numériques, HTTPS et authentification TLS
Rôle des certificats dans HTTPS
Le protocole HTTPS correspond à l'utilisation de HTTP au-dessus de TLS. Il permet de protéger les communications entre un client et un serveur contre certaines formes d'interception et de modification.
Le certificat TLS contribue à authentifier le serveur auquel le client souhaite se connecter.
Transport Layer Security
Transport Layer Security, ou TLS, est un protocole cryptographique utilisé pour établir des communications sécurisées.
Il combine des mécanismes d'authentification, de négociation de paramètres cryptographiques et de protection des données échangées.
Présentation du certificat serveur
Lors d'une connexion TLS utilisant des certificats, le serveur transmet son certificat et généralement les certificats intermédiaires nécessaires.
Le client doit ensuite vérifier que le certificat est valide pour le service demandé et que sa chaîne est acceptable.
Preuve de possession de la clé privée
La présentation d'un certificat ne suffit pas. Le serveur doit également prouver, au cours du protocole TLS, qu'il possède la clé privée associée au certificat.
Dans TLS 1.3 avec authentification par certificat, cette preuve intervient notamment au moyen du message CertificateVerify.
Établissement des clés de session
Les communications applicatives ne sont généralement pas chiffrées directement avec la clé publique du certificat.
Dans TLS 1.3, les clés de session sont dérivées à partir du mécanisme d'échange de clés et du protocole de dérivation. Le certificat sert principalement à authentifier l'entité qui participe à l'échange.
Vérification du nom de domaine
Le navigateur vérifie que le nom du serveur demandé correspond à une identité autorisée par le certificat, généralement indiquée dans l'extension SAN.
Un certificat parfaitement signé mais délivré pour un autre domaine ne doit pas être accepté pour le serveur demandé.
Authentification mutuelle TLS
Le mécanisme Mutual TLS, ou mTLS, permet au serveur de demander également un certificat au client.
Le serveur peut alors vérifier l'identité cryptographique du client, sous réserve de disposer d'une politique de confiance et d'autorisation adaptée.
Applications du mTLS
Le mTLS est notamment utilisé dans certains environnements d'entreprise, les architectures de microservices, les API privées et les communications entre équipements.
Il permet d'ajouter une authentification cryptographique des clients au-delà de la simple authentification du serveur.
Erreurs fréquentes de validation TLS
- Certificat expiré : sa date de fin de validité est dépassée.
- Nom incorrect : le domaine demandé ne correspond pas au certificat.
- Autorité inconnue : aucune chaîne de confiance acceptable n'a été trouvée.
- Certificat révoqué : le certificat a été invalidé selon les mécanismes et politiques appliqués.
- Chaîne incomplète : des certificats intermédiaires nécessaires sont absents ou introuvables.
- Usage non autorisé : les extensions ne permettent pas l'utilisation envisagée.
7. Signatures numériques et applications des certificats
Signature numérique de documents
Une signature numérique permet de vérifier l'intégrité de données et leur association à une clé privée. Elle peut être appliquée à des documents, des messages ou des fichiers.
Un certificat peut permettre de relier la clé publique utilisée pour la vérification à une identité reconnue selon les règles d'une infrastructure de confiance.
Signature électronique et signature numérique
La signature électronique est une notion plus large pouvant recouvrir différents procédés de manifestation du consentement ou d'identification électronique.
La signature numérique désigne plus précisément un mécanisme cryptographique. Une signature numérique peut être utilisée dans un dispositif de signature électronique, mais les deux expressions ne sont pas strictement synonymes.
Signature des logiciels
Le Code Signing consiste à signer des logiciels, des exécutables ou des composants afin de permettre la vérification de leur origine cryptographique et de leur intégrité.
La présence d'une signature valide ne garantit cependant pas qu'un logiciel est dépourvu de vulnérabilités ou de comportements malveillants.
Messagerie électronique sécurisée
Le standard S/MIME permet notamment de signer et de chiffrer des messages électroniques au moyen de certificats et de mécanismes cryptographiques.
Il peut contribuer à authentifier l'origine cryptographique d'un message et à protéger son contenu.
Authentification des utilisateurs
Un certificat personnel peut être utilisé pour authentifier un utilisateur auprès d'une application ou d'un système d'information.
La preuve d'identité repose alors sur une opération impliquant la clé privée, éventuellement protégée par une carte à puce ou un autre dispositif sécurisé.
Certificats et cartes à puce
Une carte à puce cryptographique peut stocker un certificat public et conserver la clé privée correspondante dans son composant sécurisé.
Lorsqu'une application demande une signature, la carte peut effectuer l'opération sans transmettre la clé privée à l'ordinateur.
Internet des objets
Dans l'Internet of Things, ou IoT, les certificats peuvent être utilisés pour authentifier des équipements et sécuriser leurs communications.
La gestion du cycle de vie des certificats devient particulièrement importante lorsqu'un grand nombre d'appareils doivent être administrés.
VPN et accès distant
Certains systèmes VPN utilisent des certificats pour authentifier les serveurs, les utilisateurs ou les équipements.
Cette approche peut compléter d'autres mécanismes d'authentification et de contrôle d'accès.
8. Vulnérabilités, risques et bonnes pratiques de sécurité
Compromission de la clé privée
La compromission d'une clé privée constitue l'un des risques majeurs associés aux certificats numériques. Un attaquant qui obtient une clé privée peut potentiellement usurper l'identité cryptographique correspondante, dans les limites des usages autorisés.
La protection de cette clé doit être considérée comme une priorité, notamment pour les serveurs accessibles depuis Internet et les autorités de certification.
Attaque Man-in-the-Middle
Une attaque Man-in-the-Middle, ou MITM, consiste à intercepter ou à modifier des communications entre deux parties.
Une validation correcte des certificats TLS contribue à empêcher qu'un intermédiaire non autorisé puisse se faire passer pour le serveur légitime.
Certificats expirés
Un certificat expiré peut provoquer une interruption de service ou un avertissement de sécurité. Les administrateurs doivent donc surveiller les dates d'expiration et automatiser le renouvellement lorsque cela est possible.
Certificats frauduleux
Un certificat peut être délivré de manière incorrecte ou obtenu à la suite d'une compromission des procédures de validation.
La surveillance des journaux de Certificate Transparency et les procédures de révocation contribuent à la gestion de ce risque.
Certificats auto-signés non maîtrisés
Les certificats auto-signés peuvent être adaptés à certains environnements internes, mais leur utilisation nécessite une distribution contrôlée des ancres de confiance.
Accepter systématiquement tous les certificats auto-signés sans vérification crée un risque important d'usurpation.
Désactivation de la vérification TLS
Dans certains programmes, les développeurs désactivent la vérification des certificats pour contourner une erreur de configuration.
Cette pratique peut permettre à un attaquant d'intercepter les communications. Il faut corriger la configuration de confiance plutôt que désactiver les contrôles de sécurité.
Stockage non sécurisé des clés
Une clé privée conservée dans un fichier accessible à des utilisateurs non autorisés peut être copiée.
Les permissions des fichiers, le chiffrement au repos, les sauvegardes et les mécanismes matériels de protection doivent être adaptés à la sensibilité de la clé.
Hardware Security Module
Un Hardware Security Module, ou HSM, est un dispositif spécialisé destiné à protéger des clés cryptographiques et à effectuer certaines opérations sensibles.
Il est notamment utilisé dans des infrastructures de certification, des services financiers et des environnements nécessitant un niveau élevé de protection des clés.
Bonnes pratiques de sécurité
- Utiliser des algorithmes cryptographiques modernes et des paramètres adaptés.
- Protéger les clés privées contre les accès non autorisés.
- Vérifier les chaînes de certification et les noms de domaine.
- Respecter les périodes de validité des certificats.
- Automatiser le renouvellement lorsque cela est possible.
- Mettre en place des procédures de révocation.
- Surveiller les certificats délivrés pour les domaines administrés.
- Ne pas désactiver la vérification TLS.
- Utiliser des HSM ou des composants sécurisés lorsque le niveau de risque l'exige.
- Documenter les politiques de certification et de gestion des clés.
9. Pratique des certificats numériques avec Python
Présentation des bibliothèques Python
Le langage Python possède plusieurs bibliothèques permettant de manipuler les certificats et les mécanismes cryptographiques. Le module standard ssl permet notamment de travailler avec TLS, tandis que la bibliothèque externe cryptography fournit des outils de création, de lecture et de vérification de certificats X.509.
Les exemples suivants sont destinés à un environnement de laboratoire. Ils utilisent des identités fictives et ne nécessitent pas de certificat délivré par une autorité publique.
Exemple 1 : installer la bibliothèque cryptography
Avant d'utiliser les fonctionnalités X.509, il faut installer la bibliothèque cryptography. La commande suivante doit être exécutée dans un terminal. Elle utilise le gestionnaire de paquets pip associé à l'interpréteur Python.
1 | python -m pip install cryptography |
Output possible :
1 | Successfully installed cryptography-... |
La version installée et les messages affichés dépendent de l'environnement.
Exemple 2 : générer une paire de clés RSA
Le programme suivant génère une paire de clés RSA de 3072 bits. La clé privée est conservée dans une variable Python et la clé publique correspondante est obtenue par la méthode public_key(). Cet exemple constitue une première étape vers la création d'un certificat numérique.
1 2 3 4 5 6 7 8 | from cryptography.hazmat.primitives.asymmetric import rsa cle_privee = rsa.generate_private_key( public_exponent=65537, key_size=3072 ) cle_publique = cle_privee.public_key() print('Taille RSA :', cle_privee.key_size) print('Clé publique disponible :', cle_publique is not None) |
Output :
1 2 | Taille RSA : 3072 Clé publique disponible : True |
Exemple 3 : exporter une clé publique au format PEM
Le format PEM est couramment utilisé pour représenter des clés et des certificats sous une forme textuelle encodée en Base64 avec des délimiteurs explicites. Le programme suivant exporte la clé publique RSA au format PEM.
1 2 3 4 5 6 7 8 9 10 11 12 | from cryptography.hazmat.primitives.asymmetric import rsa from cryptography.hazmat.primitives import serialization cle_privee = rsa.generate_private_key( public_exponent=65537, key_size=2048 ) cle_publique = cle_privee.public_key() pem = cle_publique.public_bytes( encoding=serialization.Encoding.PEM, format=serialization.PublicFormat.SubjectPublicKeyInfo ) print(pem.decode().splitlines()[0]) |
Output :
1 | -----BEGIN PUBLIC KEY----- |
Exemple 4 : créer un certificat X.509 auto-signé
Le programme suivant génère un certificat X.509 auto-signé pour le domaine fictif localhost. Il définit une identité, une période de validité, un numéro de série, une extension SAN et une extension indiquant que le certificat n'est pas une autorité de certification. Le certificat est ensuite signé avec une clé privée RSA.
Ce certificat convient à un exercice de laboratoire, mais il n'est pas automatiquement reconnu comme fiable par les navigateurs.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 | from datetime import datetime, timedelta, timezone from cryptography import x509 from cryptography.x509.oid import NameOID from cryptography.hazmat.primitives import hashes from cryptography.hazmat.primitives.asymmetric import rsa cle = rsa.generate_private_key( public_exponent=65537, key_size=2048 ) nom = x509.Name([ x509.NameAttribute(NameOID.COMMON_NAME, 'localhost') ]) maintenant = datetime.now(timezone.utc) certificat = ( x509.CertificateBuilder() .subject_name(nom) .issuer_name(nom) .public_key(cle.public_key()) .serial_number(x509.random_serial_number()) .not_valid_before(maintenant) .not_valid_after(maintenant + timedelta(days=30)) .add_extension( x509.SubjectAlternativeName([ x509.DNSName('localhost') ]), critical=False ) .add_extension( x509.BasicConstraints(ca=False, path_length=None), critical=True ) .sign(cle, hashes.SHA256()) ) print('Sujet :', certificat.subject.rfc4514_string()) print('Émetteur :', certificat.issuer.rfc4514_string()) print('Version :', certificat.version.name) |
Output :
1 2 3 | Sujet : CN=localhost Émetteur : CN=localhost Version : v3 |
Exemple 5 : enregistrer un certificat au format PEM
Le programme suivant suppose que la variable certificat a été créée dans l'exemple précédent. Il utilise la méthode public_bytes() pour enregistrer le certificat dans un fichier PEM. Ce fichier contient uniquement le certificat public, et non la clé privée.
1 2 3 4 5 6 7 8 | from cryptography.hazmat.primitives import serialization donnees = certificat.public_bytes( serialization.Encoding.PEM ) with open('certificat_demo.pem', 'wb') as fichier: fichier.write(donnees) print('Certificat enregistré') print('Taille supérieure à zéro :', len(donnees) > 0) |
Output :
1 2 | Certificat enregistré Taille supérieure à zéro : True |
Exemple 6 : charger un certificat depuis un fichier
Le programme suivant lit le fichier PEM créé précédemment et le convertit en objet X.509. Cette opération permet d'accéder aux différents champs du certificat pour effectuer des analyses ou des contrôles.
1 2 3 4 5 6 | from cryptography import x509 with open('certificat_demo.pem', 'rb') as fichier: donnees = fichier.read() certificat_lu = x509.load_pem_x509_certificate(donnees) print('Sujet :', certificat_lu.subject.rfc4514_string()) print('Version :', certificat_lu.version.name) |
Output :
1 2 | Sujet : CN=localhost Version : v3 |
Exemple 7 : consulter les dates de validité
Le programme suivant utilise les propriétés temporelles du certificat pour vérifier si la date actuelle appartient à sa période de validité. Cette vérification est nécessaire, mais elle ne suffit pas à établir la confiance dans le certificat.
1 2 3 4 5 6 | from datetime import datetime, timezone maintenant = datetime.now(timezone.utc) debut = certificat_lu.not_valid_before_utc fin = certificat_lu.not_valid_after_utc valide = debut <= maintenant <= fin print('Certificat dans sa période de validité :', valide) |
Output attendu :
1 | Certificat dans sa période de validité : True |
Cette sortie suppose que le certificat vient d'être créé et que sa période de validité n'est pas dépassée.
Exemple 8 : lire les noms de domaine SAN
Le programme suivant extrait les noms de domaine présents dans l'extension Subject Alternative Name. Cette extension est essentielle pour vérifier qu'un certificat TLS correspond au nom du serveur demandé.
1 2 3 4 5 6 | from cryptography import x509 extension = certificat_lu.extensions.get_extension_for_class( x509.SubjectAlternativeName ) domaines = extension.value.get_values_for_type(x509.DNSName) print('Domaines SAN :', domaines) |
Output :
1 | Domaines SAN : ['localhost'] |
Exemple 9 : calculer l'empreinte SHA-256 d'un certificat
L'empreinte numérique d'un certificat est une valeur calculée à partir de ses données. Elle peut servir à identifier précisément un certificat ou à comparer deux exemplaires.
Le programme suivant calcule l'empreinte SHA-256 du certificat chargé. L'empreinte change lorsque les données du certificat changent.
1 2 3 4 | from cryptography.hazmat.primitives import hashes empreinte = certificat_lu.fingerprint(hashes.SHA256()) print('Taille de l empreinte :', len(empreinte)) print('Algorithme : SHA-256') |
Output :
1 2 | Taille de l empreinte : 32 Algorithme : SHA-256 |
Exemple 10 : créer une demande CSR
Une Certificate Signing Request contient des informations sur le demandeur et sa clé publique. Le programme suivant crée une demande CSR pour le domaine fictif example.test, puis la signe avec la clé privée correspondante.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | from cryptography import x509 from cryptography.x509.oid import NameOID from cryptography.hazmat.primitives import hashes from cryptography.hazmat.primitives.asymmetric import rsa cle = rsa.generate_private_key( public_exponent=65537, key_size=2048 ) csr = ( x509.CertificateSigningRequestBuilder() .subject_name(x509.Name([ x509.NameAttribute( NameOID.COMMON_NAME, 'example.test' ) ])) .add_extension( x509.SubjectAlternativeName([ x509.DNSName('example.test') ]), critical=False ) .sign(cle, hashes.SHA256()) ) print('Sujet CSR :', csr.subject.rfc4514_string()) print('Signature valide :', csr.is_signature_valid) |
Output :
1 2 | Sujet CSR : CN=example.test Signature valide : True |
Exemple 11 : signer un message avec une clé privée RSA
Le programme suivant démontre le principe de la signature numérique. Une clé privée RSA signe un message en utilisant le schéma RSA-PSS et la fonction de hachage SHA-256. La clé publique correspondante vérifie ensuite la signature.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 | from cryptography.hazmat.primitives.asymmetric import rsa, padding from cryptography.hazmat.primitives import hashes cle = rsa.generate_private_key( public_exponent=65537, key_size=2048 ) message = b'Document de demonstration' signature = cle.sign( message, padding.PSS( mgf=padding.MGF1(hashes.SHA256()), salt_length=padding.PSS.MAX_LENGTH ), hashes.SHA256() ) cle.public_key().verify( signature, message, padding.PSS( mgf=padding.MGF1(hashes.SHA256()), salt_length=padding.PSS.MAX_LENGTH ), hashes.SHA256() ) print('Signature vérifiée avec succès') |
Output :
1 | Signature vérifiée avec succès |
Exemple 12 : détecter une modification du message signé
Une signature numérique doit échouer lorsque les données vérifiées ne correspondent plus aux données signées. Le programme suivant modifie le message initial et tente de vérifier la signature précédente.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | from cryptography.exceptions import InvalidSignature message_modifie = b'Document de demonstration modifie' try: cle.public_key().verify( signature, message_modifie, padding.PSS( mgf=padding.MGF1(hashes.SHA256()), salt_length=padding.PSS.MAX_LENGTH ), hashes.SHA256() ) print('Signature valide') except InvalidSignature: print('Signature invalide : document modifié') |
Output :
1 | Signature invalide : document modifié |
Exemple 13 : analyser un certificat PEM avec le module ssl
Le module standard ssl permet de travailler avec les certificats TLS. Le programme suivant utilise la fonction PEM_cert_to_DER_cert() pour convertir un certificat PEM en représentation DER.
Le format DER est une représentation binaire normalisée des données ASN.1 utilisées notamment dans X.509.
1 2 3 4 5 6 7 | import ssl with open('certificat_demo.pem', 'r', encoding='ascii') as fichier: pem = fichier.read() der = ssl.PEM_cert_to_DER_cert(pem) print('Conversion PEM vers DER réussie') print('Données binaires :', isinstance(der, bytes)) print('Taille positive :', len(der) > 0) |
Output :
1 2 3 | Conversion PEM vers DER réussie Données binaires : True Taille positive : True |
Exemple 14 : vérifier les informations d'un certificat avec une fonction Python
Le programme suivant crée une fonction d'inspection élémentaire qui contrôle la période de validité et affiche le sujet du certificat. Il s'agit d'un outil pédagogique d'analyse, et non d'un validateur complet de certificats.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | from datetime import datetime, timezone def analyser_certificat(certificat): maintenant = datetime.now(timezone.utc) valide = ( certificat.not_valid_before_utc <= maintenant <= certificat.not_valid_after_utc ) return { 'sujet': certificat.subject.rfc4514_string(), 'validite_temporelle': valide, 'version': certificat.version.name } resultat = analyser_certificat(certificat_lu) for cle, valeur in resultat.items(): print(cle, ':', valeur) |
Output attendu :
1 2 3 | sujet : CN=localhost validite_temporelle : True version : v3 |
Exemple 15 : créer un certificat avec une clé Ed25519
Le programme suivant illustre l'utilisation de l'algorithme moderne Ed25519 pour créer un certificat auto-signé. Contrairement à RSA, la méthode de signature du certificat avec Ed25519 utilise algorithm=None, car l'algorithme de signature définit lui-même son mécanisme cryptographique.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 | from datetime import datetime, timedelta, timezone from cryptography import x509 from cryptography.x509.oid import NameOID from cryptography.hazmat.primitives.asymmetric import ed25519 cle = ed25519.Ed25519PrivateKey.generate() nom = x509.Name([ x509.NameAttribute(NameOID.COMMON_NAME, 'demo-ed25519') ]) maintenant = datetime.now(timezone.utc) certificat_ed = ( x509.CertificateBuilder() .subject_name(nom) .issuer_name(nom) .public_key(cle.public_key()) .serial_number(x509.random_serial_number()) .not_valid_before(maintenant) .not_valid_after(maintenant + timedelta(days=10)) .add_extension( x509.BasicConstraints(ca=False, path_length=None), critical=True ) .sign(cle, algorithm=None) ) print('Sujet :', certificat_ed.subject.rfc4514_string()) print('Algorithme :', certificat_ed.signature_algorithm_oid._name) |
Output possible :
1 2 | Sujet : CN=demo-ed25519 Algorithme : ed25519 |
La disponibilité et l'acceptation des certificats Ed25519 dépendent des applications et des environnements de confiance utilisés.
Mini projet pédagogique : gestion des certificats numériques avec Python
Pour approfondir les connaissances acquises, il est possible de développer une petite application Python destinée à gérer des certificats de laboratoire. Ce projet peut être réalisé avec cryptography et les modules standards de Python.
- Créer une paire de clés RSA.
- Exporter une clé publique au format PEM.
- Créer un certificat X.509 auto-signé.
- Ajouter une extension Subject Alternative Name.
- Enregistrer le certificat dans un fichier PEM.
- Charger un certificat existant.
- Afficher son sujet et son émetteur.
- Afficher son numéro de série.
- Vérifier sa période de validité.
- Extraire les noms de domaine SAN.
- Calculer son empreinte SHA-256.
- Créer une demande CSR.
- Signer un message avec une clé privée.
- Vérifier une signature numérique.
- Détecter une modification du message.
- Convertir un certificat PEM en DER.
- Comparer les propriétés de deux certificats.
- Détecter les certificats proches de l'expiration.
- Générer un rapport d'inspection.
- Documenter les limites des contrôles réalisés.
Ce projet permet de réunir plusieurs notions fondamentales : cryptographie asymétrique, X.509, signature numérique, certification et validation des certificats.
Il est important de distinguer l'analyse des champs d'un certificat de sa validation complète. Une application de production doit utiliser une bibliothèque de validation adaptée et une politique de confiance explicite, plutôt que de considérer qu'un certificat est fiable simplement parce que sa structure et ses dates sont correctes.
10. À retenir
Un certificat numérique est un document électronique structuré qui associe une clé publique à une identité ou à une entité. Cette association peut être authentifiée par une autorité de certification au moyen d'une signature numérique.
La cryptographie asymétrique repose sur une paire de clés publiques et privées. La clé publique peut être distribuée, tandis que la clé privée doit être protégée contre les accès non autorisés.
Le format X.509 est largement utilisé pour représenter les certificats numériques. Il contient notamment des informations sur le sujet, l'émetteur, la période de validité, la clé publique et les extensions applicables.
Une autorité de certification délivre des certificats selon une politique définie. Une PKI organise la gestion des certificats, des clés, des autorités et des mécanismes de confiance.
La chaîne de certification permet de relier un certificat final à une ancre de confiance. Sa validation nécessite plusieurs contrôles complémentaires.
Les certificats jouent un rôle fondamental dans HTTPS et TLS, notamment pour l'authentification des serveurs et la protection des communications.
Les signatures numériques permettent de vérifier l'intégrité de données et leur association à une clé cryptographique. Elles interviennent notamment dans la signature de documents, de logiciels et de messages électroniques.
Les mécanismes de révocation, de renouvellement et de surveillance sont indispensables pour assurer une gestion correcte du cycle de vie des certificats.
La sécurité dépend fortement de la protection des clés privées, de la fiabilité des autorités, de la vérification des noms de domaine et de l'application des politiques de confiance.
Enfin, le langage Python, notamment avec la bibliothèque cryptography, permet de générer des clés, créer des certificats X.509, produire des demandes CSR, inspecter des certificats et réaliser des signatures numériques.
Auteur : Younes Derfoufi
Lieu de travail : CRMEF OUJDA
Site Web : www.tresfacile.net
Chaine YouTube : https://www.youtube.com/user/InformatiquesFacile
Me contacter : https://www.tresfacile.net/me-contacter/



