cedricAbonnel/notes-techniques
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

INIT

Browse Source
This commit is contained in:
Cédric Abonnel
2024-07-21 13:30:18 +02:00
commit 3bbf23924e
5 changed files with 586 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

427
notes/certificats/creer_une_autorite_de_certification_CA_privee.md Normal file
View File

@@ -0,0 +1,427 @@
# Créer une autorité de certification (CA) privée
Cédric Abonnel - 2024-07-21
## Introduction
Une autorité de certification (CA) est une entité responsable de l'émission de certificats numériques pour vérifier les identités en ligne. Bien que les CA publiques soient couramment utilisées pour authentifier les sites Web et les services accessibles au grand public, les CA privées sont souvent employées pour des groupes restreints et des services internes.
La création d'une autorité de certification privée permet de configurer, tester et exécuter des applications nécessitant des connexions chiffrées entre un client et un serveur. Une CA privée vous permet d'émettre des certificats pour des utilisateurs, des serveurs ou des services spécifiques au sein de votre infrastructure.
Par exemple, des programmes sous Linux comme OpenVPN et Puppet utilisent leurs propres CA privées. Vous pouvez également configurer votre serveur web pour utiliser des certificats émis par une CA privée, alignant ainsi les environnements de développement et de staging avec les serveurs de production utilisant TLS pour sécuriser les connexions.
Ce guide explique comment configurer une **CA privée** sur un serveur Debian 12 et comment générer et signer un certificat de test avec cette nouvelle CA. Vous apprendrez également à importer le certificat public de la CA dans le magasin de certificats de votre système d'exploitation pour vérifier la chaîne de confiance entre la CA et les serveurs ou utilisateurs distants. Enfin, vous découvrirez comment révoquer des certificats et distribuer une liste de révocation des certificats, garantissant ainsi que seuls les utilisateurs et systèmes autorisés puissent accéder aux services dépendant de votre CA.
## Sommaire
1. **Configuration de la CA Privée :**
- Installation des outils nécessaires comme `OpenSSL`.
- Création d'une structure de répertoires pour stocker les fichiers de la CA.
- Génération d'une paire de clés privée et publique pour la CA.
- Création d'un certificat de la CA en utilisant sa clé publique.
2. **Génération et Signature de Certificats :**
- Création de demandes de signature de certificat (CSR) pour les utilisateurs, serveurs ou services.
- Utilisation de la CA pour signer les CSR, générant ainsi des certificats validés.
3. **Intégration du Certificat Public :**
- Ajout du certificat public de la CA dans le magasin de certificats de systèmes clients.
- Vérification de la chaîne de confiance lors des connexions sécurisées.
4. **Révocation de Certificats :**
- Procédure de révocation de certificats compromis ou obsolètes.
- Distribution et mise à jour d'une liste de révocation de certificats (CRL) pour informer les clients des certificats révoqués.
En suivant ce guide, vous serez capable de mettre en place une CA privée robuste, garantissant la sécurité et l'intégrité des communications au sein de votre infrastructure.
## Configuration de la CA Privée
1. **Installation des outils nécessaires :**
Pour configurer une autorité de certification (CA) privée sur Debian 12, vous aurez besoin de l'outil `OpenSSL`. Commencez par mettre à jour vos paquets et installer `OpenSSL`.
```bash
sudo apt update
sudo apt install openssl
```
2. **Création d'une structure de répertoires pour stocker les fichiers de la CA :**
Il est important d'organiser les fichiers de votre CA de manière structurée. Créez les répertoires nécessaires pour stocker les certificats, les clés, les nouvelles requêtes de certificats et d'autres fichiers importants.
```bash
mkdir -p ~/myCA/{certs,crl,newcerts,private}
chmod 700 ~/myCA/private
touch ~/myCA/index.txt
echo 1000 > ~/myCA/serial
```
- `certs` : Ce répertoire contiendra les certificats émis.
- `crl` : Ce répertoire contiendra les listes de révocation de certificats (CRL).
- `newcerts` : Ce répertoire contiendra les nouveaux certificats émis.
- `private` : Ce répertoire contiendra les clés privées de la CA (accès restreint).
- `index.txt` : Ce fichier est utilisé pour suivre les certificats émis.
- `serial` : Ce fichier contient le numéro de série du prochain certificat à émettre.
3. **Génération d'une paire de clés privée et publique pour la CA :**
La clé privée de la CA est cruciale et doit être protégée. La clé publique sera utilisée pour générer le certificat de la CA.
```bash
openssl genpkey -algorithm RSA -out ~/myCA/private/ca.key -aes256
```
Cette commande génère une clé privée RSA avec un chiffrement AES-256 pour protéger la clé. Vous serez invité à entrer une phrase secrète pour sécuriser cette clé.
4. **Création d'un certificat de la CA en utilisant sa clé publique :**
Utilisez la clé privée de la CA pour créer un certificat auto-signé. Ce certificat servira à signer les certificats des autres entités (utilisateurs, serveurs, etc.).
```bash
openssl req -new -x509 -days 3650 -key ~/myCA/private/ca.key -out ~/myCA/certs/ca.crt
```
Vous devrez fournir des informations sur votre CA lors de la génération du certificat, telles que :
- Country Name (2 letter code) [XX]:
- State or Province Name (full name) []:
- Locality Name (eg, city) [Default City]:
- Organization Name (eg, company) [Default Company Ltd]:
- Organizational Unit Name (eg, section) []:
- Common Name (eg, your name or your server's hostname) []:
- Email Address []:
Lorsque vous configurez une autorité de certification (CA) privée pour un usage personnel, vous pouvez personnaliser les informations selon votre situation. Voici un exemple de ce que vous pouvez entrer :
- **Country Name (2 letter code) [XX]** : Utilisez le code de votre pays, par exemple `FR` pour la France.
- **State or Province Name (full name) []** : Indiquez votre région ou province. Vous pouvez laisser ce champ vide si vous le souhaitez.
- **Locality Name (eg, city) [Default City]** : Indiquez votre ville, par exemple `Paris`.
- **Organization Name (eg, company) [Default Company Ltd]** : Si vous êtes un particulier, vous pouvez mettre votre nom, par exemple `John Doe`.
- **Organizational Unit Name (eg, section) []** : Vous pouvez laisser ce champ vide ou indiquer quelque chose de générique comme `Personal`.
- **Common Name (eg, your name or your server's hostname) []** : Utilisez votre nom ou un nom descriptif pour votre CA, par exemple `John Doe CA`.
- **Email Address []** : Indiquez votre adresse email, par exemple `john.doe@example.com`.
Voici un exemple complet :
```plaintext
Country Name (2 letter code) [XX]: FR
State or Province Name (full name) []: Île-de-France
Locality Name (eg, city) [Default City]: Paris
Organization Name (eg, company) [Default Company Ltd]: John Doe
Organizational Unit Name (eg, section) []: Personal
Common Name (eg, your name or your server's hostname) []: John Doe CA
Email Address []: john.doe@example.com
```
En suivant ces indications, vous aurez correctement configuré les informations de votre CA privée pour un usage personnel.
Le certificat créé (`ca.crt`) sera valide pendant 10 ans (3650 jours).
En suivant ces étapes, vous aurez configuré une structure de base pour votre CA privée sur Debian 12, prête à émettre et gérer des certificats au sein de votre infrastructure.
## Génération et Signature de Certificats
Dans cette section, nous allons détailler les étapes pour créer des demandes de signature de certificat (CSR) et signer ces demandes en utilisant votre autorité de certification (CA) privée.
### Création de demandes de signature de certificat (CSR)
Une demande de signature de certificat (Certificate Signing Request, CSR) est un fichier envoyé à une autorité de certification (CA) pour demander la signature et l'émission d'un certificat numérique. Ce fichier contient les informations nécessaires pour générer le certificat, notamment la clé publique, et les informations sur l'identité du demandeur.
#### Étapes pour créer une CSR :
1. **Génération d'une paire de clés privée et publique pour l'utilisateur ou le serveur :**
```bash
openssl genpkey -algorithm RSA -out user.key
```
Cette commande génère une clé privée RSA pour l'utilisateur ou le serveur.
2. **Création de la CSR en utilisant la clé privée générée :**
```bash
openssl req -new -key user.key -out user.csr
```
Vous devrez fournir des informations similaires à celles données lors de la création de la CA. Voici un exemple de ce que vous pouvez entrer :
- **Country Name (2 letter code) [XX]** : `FR`
- **State or Province Name (full name) []** : `Île-de-France`
- **Locality Name (eg, city) [Default City]** : `Paris`
- **Organization Name (eg, company) [Default Company Ltd]** : `John Doe`
- **Organizational Unit Name (eg, section) []** : `Personal`
- **Common Name (eg, your name or your server's hostname) []** : `user.example.com`
- **Email Address []** : `user@example.com`
### Utilisation de la CA pour signer les CSR, générant ainsi des certificats validés
Une fois que vous avez créé une CSR, vous pouvez utiliser votre CA privée pour la signer et générer un certificat validé.
#### Étapes pour signer une CSR :
1. **Création d'un fichier de configuration OpenSSL pour la CA (si ce n'est pas déjà fait) :**
Créez un fichier `openssl.cnf` dans le répertoire `~/myCA/` avec le contenu suivant :
```ini
[ ca ]
default_ca = CA_default
[ CA_default ]
dir = ~/myCA
certs = $dir/certs
crl_dir = $dir/crl
new_certs_dir = $dir/newcerts
database = $dir/index.txt
serial = $dir/serial
RANDFILE = $dir/private/.rand
private_key = $dir/private/ca.key
certificate = $dir/certs/ca.crt
crlnumber = $dir/crlnumber
crl = $dir/crl.pem
crl_extensions = crl_ext
default_crl_days = 30
default_days = 365
default_md = sha256
policy = policy_strict
[ policy_strict ]
countryName = match
stateOrProvinceName = match
organizationName = match
organizationalUnitName = optional
commonName = supplied
emailAddress = optional
[ req ]
default_bits = 2048
default_md = sha256
default_keyfile = privkey.pem
distinguished_name = req_distinguished_name
x509_extensions = v3_ca
[ req_distinguished_name ]
countryName = Country Name (2 letter code)
stateOrProvinceName = State or Province Name (full name)
localityName = Locality Name (eg, city)
organizationName = Organization Name (eg, company)
organizationalUnitName = Organizational Unit Name (eg, section)
commonName = Common Name (eg, your name or your server's hostname)
emailAddress = Email Address
[ v3_ca ]
subjectKeyIdentifier=hash
authorityKeyIdentifier=keyid:always,issuer
basicConstraints = CA:TRUE
```
2. **Utilisation de la CA pour signer la CSR :**
```bash
openssl ca -in user.csr -out user.crt -config ~/myCA/openssl.cnf
```
Cette commande utilise le fichier de configuration `openssl.cnf` pour signer la CSR et générer un certificat (`user.crt`). Vous serez invité à confirmer l'émission du certificat et à fournir la phrase secrète de votre CA.
#### Résultat :
Une fois ces étapes terminées, vous aurez un certificat validé (`user.crt`) pour l'utilisateur ou le serveur correspondant à la CSR. Vous pouvez maintenant utiliser ce certificat pour établir des connexions sécurisées entre le client et le serveur.
## Intégration du Certificat Public
L'intégration du certificat public de la CA dans le magasin de certificats des systèmes clients est une étape cruciale pour établir la confiance entre les clients et les serveurs utilisant des certificats émis par cette CA. Voici comment procéder :
### Ajout du certificat public de la CA dans le magasin de certificats des systèmes clients
Pour que les systèmes clients puissent faire confiance aux certificats émis par votre CA, ils doivent inclure le certificat public de la CA dans leur magasin de certificats. Voici les étapes pour différentes plateformes :
#### Sur Linux (Debian/Ubuntu)
1. **Copie du certificat public de la CA dans le répertoire des certificats de confiance :**
```bash
sudo cp ~/myCA/certs/ca.crt /usr/local/share/ca-certificates/
```
2. **Mise à jour du magasin de certificats :**
```bash
sudo update-ca-certificates
```
Cette commande ajoute le certificat de la CA au magasin de certificats de confiance du système.
#### Sur Windows
1. **Ouvrir la Console de Gestion des Certificats :**
Appuyez sur `Win + R`, tapez `mmc` et appuyez sur Entrée. Dans la console MMC, ajoutez le snap-in "Certificates" pour "Computer account".
2. **Importer le certificat de la CA :**
- Naviguez jusqu'à `Trusted Root Certification Authorities > Certificates`.
- Faites un clic droit et sélectionnez `All Tasks > Import`.
- Suivez l'assistant pour importer le fichier `ca.crt`.
#### Sur macOS
1. **Ouvrir le Trousseau d’Accès (Keychain Access) :**
Vous pouvez le trouver dans `Applications > Utilitaires > Trousseau d'accès`.
2. **Importer le certificat :**
- Sélectionnez le trousseau `Système` (System).
- Faites glisser le fichier `ca.crt` dans la fenêtre du trousseau.
- Vous pouvez également utiliser le menu `Fichier > Importer des éléments`.
### Vérification de la chaîne de confiance lors des connexions sécurisées
Une fois le certificat public de la CA ajouté au magasin de certificats de confiance des systèmes clients, ces derniers pourront vérifier la chaîne de confiance lors des connexions sécurisées. Voici comment cela fonctionne :
#### Principe de la chaîne de confiance
- **Client et serveur échangent des certificats :** Lorsqu'un client se connecte à un serveur sécurisé, le serveur présente son certificat.
- **Vérification par le client :** Le client vérifie si le certificat du serveur a été émis par une CA de confiance en comparant la chaîne de certificats avec ceux dans son magasin de certificats.
- **Établissement de la connexion sécurisée :** Si le certificat du serveur est validé, la connexion sécurisée est établie. Sinon, le client reçoit un avertissement ou refuse la connexion.
#### Exemple de vérification sous Linux
Pour vérifier si le certificat du serveur est correctement validé par le client, vous pouvez utiliser des outils comme `openssl` :
```bash
openssl s_client -connect server.example.com:443 -CAfile /usr/local/share/ca-certificates/ca.crt
```
Cette commande tente de se connecter au serveur `server.example.com` sur le port 443 (HTTPS) et utilise le certificat de la CA pour valider le certificat du serveur.
#### Exemple de vérification sous Windows
Utilisez un navigateur web ou des outils comme `CertUtil` pour vérifier la chaîne de confiance. Par exemple, dans PowerShell :
```powershell
CertUtil -verify -urlfetch "C:\path\to\server.crt"
```
#### Exemple de vérification sous macOS
Utilisez le trousseau d'accès (Keychain Access) pour vérifier les certificats. Naviguez jusqu'au certificat du serveur et inspectez la chaîne de certificats pour vous assurer qu'elle mène à une CA de confiance.
En suivant ces étapes, vous pouvez intégrer le certificat public de votre CA dans les systèmes clients et vérifier la chaîne de confiance lors des connexions sécurisées, garantissant ainsi la fiabilité des communications dans votre infrastructure.
## Révocation de Certificats
La révocation de certificats est une procédure importante pour maintenir la sécurité et l'intégrité de votre infrastructure. Si un certificat est compromis ou n'est plus nécessaire, il doit être révoqué pour éviter toute utilisation non autorisée.
### Procédure de révocation de certificats compromis ou obsolètes
La révocation d'un certificat signifie que ce certificat n'est plus considéré comme valide par la CA. Voici les étapes pour révoquer un certificat :
1. **Identifier le certificat à révoquer :**
Vous devez connaître le fichier de certificat (`.crt`) ou son numéro de série. Par exemple, si vous avez un certificat nommé `user.crt`.
2. **Révoquer le certificat à l'aide d'OpenSSL :**
Utilisez la commande suivante pour révoquer le certificat :
```bash
openssl ca -revoke /path/to/user.crt -config ~/myCA/openssl.cnf
```
Cette commande marque le certificat comme révoqué dans la base de données de la CA (`index.txt`).
- `/path/to/user.crt` : chemin du certificat à révoquer.
- `~/myCA/openssl.cnf` : chemin du fichier de configuration de la CA.
### Distribution et mise à jour d'une liste de révocation de certificats (CRL)
Une liste de révocation de certificats (CRL) est un fichier qui contient tous les certificats révoqués par la CA. Cette liste doit être régulièrement mise à jour et distribuée aux systèmes clients pour qu'ils puissent vérifier l'état des certificats.
1. **Générer une liste de révocation de certificats (CRL) :**
Après avoir révoqué un certificat, générez une nouvelle CRL pour inclure le certificat révoqué :
```bash
openssl ca -gencrl -out ~/myCA/crl/crl.pem -config ~/myCA/openssl.cnf
```
Cette commande crée ou met à jour le fichier `crl.pem` avec les informations des certificats révoqués.
2. **Distribuer la CRL :**
La CRL doit être accessible aux systèmes clients pour qu'ils puissent vérifier les certificats lors des connexions sécurisées. Voici quelques méthodes pour distribuer la CRL :
- **Serveur Web :** Hébergez la CRL sur un serveur web accessible. Par exemple, placez `crl.pem` dans un répertoire accessible par HTTP ou HTTPS.
```plaintext
http://your-domain.com/crl.pem
```
- **LDAP :** Si vous utilisez un annuaire LDAP, vous pouvez stocker la CRL dans l'annuaire et la rendre disponible pour les clients.
3. **Mise à jour des clients avec la nouvelle CRL :**
Les clients doivent être configurés pour récupérer et utiliser la CRL. Voici comment faire sur différentes plateformes :
#### Sur Linux
Utilisez OpenSSL pour vérifier un certificat avec une CRL :
```bash
openssl verify -crl_check -CAfile /path/to/ca.crt -CRLfile /path/to/crl.pem /path/to/user.crt
```
#### Sur Windows
Configurez les navigateurs ou applications pour utiliser la CRL hébergée. Par exemple, dans Internet Explorer ou Chrome, les paramètres de sécurité permettent de vérifier les certificats contre les CRL.
#### Sur macOS
Importez la CRL dans le Trousseau d'accès (Keychain Access) :
- Ouvrez `Keychain Access`.
- Sélectionnez `File > Import Items...`.
- Importez le fichier `crl.pem`.
### Automatisation de la mise à jour de la CRL
Pour garantir que la CRL est toujours à jour, vous pouvez automatiser sa génération et distribution. Par exemple, utilisez un script cron sur votre serveur CA pour régénérer et mettre à jour la CRL régulièrement :
```bash
#!/bin/bash
# Générer la nouvelle CRL
openssl ca -gencrl -out ~/myCA/crl/crl.pem -config ~/myCA/openssl.cnf
# Copier la CRL vers le répertoire web
cp ~/myCA/crl/crl.pem /var/www/html/crl.pem
# Optionnel : ajouter d'autres étapes de distribution
```
Ajoutez ce script à votre crontab pour qu'il s'exécute régulièrement :
```bash
crontab -e
```
Ajoutez la ligne suivante pour exécuter le script chaque jour à minuit :
```plaintext
0 0 * * * /path/to/update_crl.sh
```
En suivant ces étapes, vous pourrez révoquer des certificats compromis ou obsolètes et maintenir une CRL à jour, garantissant ainsi la sécurité de votre infrastructure.
## Références
https://ca-ra.org/fr/comment-installer-et-configurer-une-autorit%C3%A9-de-certification-ca-sur-ubuntu-20-04/