« Installation et configuration de OpenSSL » : différence entre les versions

Aller à la navigation Aller à la recherche

Installation et configuration de OpenSSL (voir la source)

Version du 3 octobre 2020 à 22:37

5 292 octets ajoutés ,  3 octobre 2020
→‎le fichier /etc/openssl.cnf
(38 versions intermédiaires par le même utilisateur non affichées)
Ligne 1 : Ligne 1 :
Ce howto a été écrit au départ pour debian etch puis a été adapté pour debian lenny. Il reste cependant valable la plupart du temps pour ces deux versions de debian.
[[Category:serveur]]
 
[[Category:debian]]
Protéger les données qui transitent au travers des différents protocoles peut parfois être primordial. Le chiffrement le plus utilisé actuellement est SSL. Le principe de SSL est basé sur l'utilisation de deux clés : une clé publique qui sert à déchiffrer et une clé privée qui sert à chiffrer (on parle de chiffrement asymétrique). La clé privée doit rester confidentielle alors que la clé publique peut-être transmise sans problème à tous le monde.
Protéger les données qui transitent au travers des différents protocoles peut parfois être primordial. Le chiffrement le plus utilisé actuellement est SSL. Le principe de SSL est basé sur l'utilisation de deux clés : une clé publique qui sert à déchiffrer et une clé privée qui sert à chiffrer (on parle de chiffrement asymétrique). La clé privée doit rester confidentielle alors que la clé publique peut-être transmise sans problème à tous le monde.
La validité des clés publiques est assurée par une autorité de certification.
La validité des clés publiques est assurée par une autorité de certification.
Ligne 25 : Ligne 25 :


* basicConstraints
* basicConstraints
** pathlen : profondeur de la clé, c''est-à-dire, le nombre de certificats pouvant apparaître sous le certificat en question (on parle de chaine de certification). Cette directive est capitale si vous souhaitez mettre en place une chaine de certification avec plusieurs autorités de certification (AC). La dernière autorité de la chaine devrait avoir une profondeur de 0 (c'est l'autorité qui sera chargée de délivrer les certificats clients et serveurs).
** <div id="pathlen"></div>pathlen : profondeur de la clé, c''est-à-dire, le nombre de certificats pouvant apparaître sous le certificat en question (on parle de chaine de certification). Cette directive est capitale si vous souhaitez mettre en place une chaine de certification avec plusieurs autorités de certification (AC). La dernière autorité de la chaine devrait avoir une profondeur de 0 (c'est l'autorité qui sera chargée de délivrer les certificats clients et serveurs).
** CA : TRUE pour une autorité, FALSE pour un certificat serveur ou client.
** CA : TRUE pour une autorité, FALSE pour un certificat serveur ou client.
* keyUsage
* keyUsage
Ligne 77 : Ligne 77 :
touch /etc/ssl/root_ca/index.txt
touch /etc/ssl/root_ca/index.txt
touch /etc/ssl/core_ca/index.txt
touch /etc/ssl/core_ca/index.txt
echo 01 > /etc/ssl/root_ca/serial
touch /etc/ssl/root_ca/serial
echo 01 > /etc/ssl/core_ca/serial
touch /etc/ssl/core_ca/serial
</pre>
</pre>


==le fichier /etc/openssl.cnf==
Ensuite nous allons configurer <code>/etc/ssl/openssl.cnf</code> pour qu'il reconnaisse cette arborescence.
Ensuite nous allons configurer <code>/etc/ssl/openssl.cnf</code> pour qu'il reconnaisse cette arborescence.
La configuration est divisée en plusieurs section qui commencent chacune par <code>[ nom_de_section ]</code>.
La configuration est divisée en plusieurs sections qui commencent chacune par <code>[ nom_de_section ]</code>.
Modifiez le fichier <code>/etc/ssl/openssl.cnf</code> comme suit :
Modifiez le fichier <code>/etc/ssl/openssl.cnf</code> comme suit :


<pre>
<pre>
openssl_conf = default_conf
[ ca ]
[ ca ]
#Cette section nous permet de définir l'autorité de certification par défaut.
#Cette section nous permet de définir l'autorité de certification par défaut.
Ligne 100 : Ligne 102 :
private_key    = $dir/private/root_ca.key
private_key    = $dir/private/root_ca.key
default_days    = 3650
default_days    = 3650
default_md      = sha1
default_md      = sha256
preserve        = no
preserve        = no
policy          = policy_match
policy          = policy_match
#unique_subject = no # Set to 'no' to allow creation of several certs with same subject.


#l'autorité de certification intermédiaire valable 10 ans
#l'autorité de certification intermédiaire valable 10 ans
Ligne 114 : Ligne 117 :
private_key    = $dir/private/core_ca.key
private_key    = $dir/private/core_ca.key
default_days    = 3650
default_days    = 3650
default_md      = sha1
default_md      = sha256
preserve        = no   
preserve        = no   
policy          = policy_match
policy          = policy_match
#unique_subject = no # Set to 'no' to allow creation of several certs with same subject.
</pre>
</pre>


Ligne 143 : Ligne 147 :
<pre>
<pre>
[ req ]
[ req ]
default_bits            = 2048
default_bits            = 4096
distinguished_name      = req_distinguished_name
distinguished_name      = req_distinguished_name
string_mask = utf8only


[ req_distinguished_name ]
[ req_distinguished_name ]
Ligne 174 : Ligne 179 :
</pre>
</pre>


Enfin, nous allons créer une section spécifique aux autorités de certification que nous allons mettre en place :
<pre>
[default_conf]
ssl_conf = ssl_sect
 
[ssl_sect]
system_default = system_default_sect
 
[system_default_sect]
MinProtocol = TLSv1.2
CipherString = DEFAULT@SECLEVEL=2
</pre>
 
Enfin, nous allons créer une section spécifique pour la configuration des certificats des autorités de certification que nous allons mettre en place :
<pre>
<pre>
[ROOT_CA]
[ROOT_CA]
Ligne 193 : Ligne 210 :
</pre>
</pre>


Faites attention à la directive <code>pathlen</code> : si vous décidez de créer plus (ou moins) d'autorités intermédiaires, il vous faudra l'adapter en conséquence. Pour plus d'informations, rendez vous [[#pathlen|ici]]
==Création de l'autorité root==
===V1===
Maintenant nous pouvons créer le certificat de l'autorité de certification :
Maintenant nous pouvons créer le certificat de l'autorité de certification :
<pre>
<pre>
cd /etc/ssl/root_ca/
cd /etc/ssl/root_ca/
openssl req -x509 -config /etc/ssl/openssl.cnf -newkey rsa:4096 -extensions ROOT_CA -days 3650 -keyout private/root_ca.key -out root_ca.pem
openssl req -x509 -config /etc/ssl/openssl.cnf -newkey rsa:8192 -sha256 -extensions ROOT_CA -days 3650 -keyout private/root_ca.key -out root_ca.pem
</pre>
</pre>


Ligne 202 : Ligne 224 :
* req permet de créer des des demandes de certificats.
* req permet de créer des des demandes de certificats.
* -x509 permet de créer un certificat auto-signé au lieu d'une simple demande de certificat.
* -x509 permet de créer un certificat auto-signé au lieu d'une simple demande de certificat.
* -newkey rsa:4096 permet de créer la clé privée en même temps ; L'algorithme de chiffrement RSA est utilisé avec une clé de 4096 bits.
* -newkey rsa:8192 permet de créer la clé privée en même temps ; L'algorithme de chiffrement RSA est utilisé avec une clé de 8192 bits.
* -extensions ROOT_CA spécifie qu'il faut utiliser la section [ROOT_CA] du fichier de configuration de openssl pour configurer le certificat.
* -extensions ROOT_CA spécifie qu'il faut utiliser la section [ROOT_CA] du fichier de configuration de openssl pour configurer le certificat.
* -days 3650 permet de définir la durée de validité du certificat. Ici, 3650 jours.
* -days 3650 permet de définir la durée de validité du certificat. Ici, 3650 jours.
Ligne 215 : Ligne 237 :
</pre>
</pre>


L'autorité de certification root est maintenant créée. Nous allons créer l'autorité intermédiaire :
Nous allons ensuite initialiser le serial par un nombre aléatoire
<pre>openssl x509 -serial -noout -in root_ca.pem | cut -d= -f2 > serial</pre>
 
===V2===
 
<pre>openssl req -new -newkey rsa:2048 -keyout private/cakey.pem -out careq.pem -config /etc/ssl/openssl.cnf </pre>
 
<pre>openssl ca -create_serial -out cacert.pem -days 365 -keyfile private/cakey.pem -selfsign -config /etc/ssl/openssl.cnf -infiles careq.pem </pre>
 
-create_serial est important et permet d'initialiser un sérial aléatoire de 128 bits.
 
Passer par ces deux commandes (plutôt que tout créer directement par <code>req</code>) est nécessaire car <code>req</code> ne supporte pas -create_serial
 
see https://www.phildev.net/ssl/creating_ca.html
 
==Création de l'autorité intermédiaire==
L'autorité de certification root est maintenant créée. Nous allons créer l'autorité intermédiaire.
On commence par créer une nouvelle clé privé ainsi qu'une demande de certificat :
<pre>
<pre>
cd /etc/ssl/core_ca
cd /etc/ssl/core_ca
#On commence par créer une nouvelle clé privé ainsi qu'une demande de certificat
openssl req -newkey rsa:8192 -sha256 -keyout private/core_ca.key -out core_ca.req
openssl req -newkey rsa:4096 -keyout private/core_ca.key -out core_ca.req
</pre>
#Puis on signe le certificat en utilisant la ca par défaut (défini dans le fichier openssl.cnf), c'est-à-dire, la CA_ROOT.
Puis on signe le certificat en utilisant la ca par défaut (défini dans le fichier openssl.cnf), c'est-à-dire, la CA_ROOT.
#Notez qu'on précise qu'il fait configurer ce nouveau certificat en utilisant la section CORE_CA du fichier de configuration.
Notez qu'on précise qu'il faut configurer ce nouveau certificat en utilisant la section CORE_CA du fichier de configuration.
openssl ca -extensions CORE_CA -in core_ca.req -out core_ca.pem
<pre>
#enfin, on s'assure que la clé privée de cette nouvelle autorité est elle aussi à l'abris.
openssl ca -extensions CORE_CA -in core_ca.req -out core_ca.pem</pre>
$ chmod -R 600 private/
 
On génère le serial de core_ca
<pre>
openssl x509 -serial -noout -in core_ca.pem | cut -d= -f2 > serial
</pre>
Enfin, on s'assure que la clé privée de cette nouvelle autorité est elle aussi à l'abri :
<pre>
chmod -R 600 private/
</pre>
 
On peut maintenant créer des certificats et les signer avec notre autorité intermédiaire.
Pour générer la clé privé et la demande de certificat :
<pre>
openssl req -newkey rsa:4096 -sha256 -keyout cle-privee.key -out cle-publique.req
</pre>
Puis on signe le certificat. L'option <code>-name</code> permet de préciser qu'il faut utiliser l'autorité <code<core_ca</code> pour signer notre nouveau certificat.
<pre>
openssl ca -name core_ca -in cle-publique.req -out certificat.pem
</pre>
 
Pour que les clients (http, mail, ftp, ...) reconnaissent comme valide les certificats que vous signez avec votre AC il faut ajouter le fichier <code>/etc/ssl/root_ca/root_ca.pem</code> (et <code>/etc/ssl/core_ca/core_ca.pem</code> si votre serveur est mal configuré) à leur liste d'autorité de certification valide.
Par exemple, pour firefox, il faut aller dans l'onglet <code>Avancé</code> de la configuration, sélectionner l'onglet <code>Chiffrement</code>, cliquer sur <code>Afficher les Certificats</code>, sélectionner l'onglet <code>Autorités</code> et cliquer sur <code>Importer</code> pour importer son certificat.
 
=Générer des certificats serveurs=
 
Pour commencer, ajoutez la section suivante dans votre fichier /etc/ssl/openssl.cnf :
<pre>
[SERVER_SSL]
nsComment                      = "SSL Server Certificate"
subjectKeyIdentifier            = hash
authorityKeyIdentifier          = keyid,issuer:always
issuerAltName                  = issuer:copy
subjectAltName                  = DNS:www.server.com, DNS:webmail.server.com
basicConstraints                = critical,CA:FALSE
keyUsage                        = critical, digitalSignature, nonRepudiation, keyEncipherment
nsCertType                      = server
extendedKeyUsage                = serverAuth
</pre>
Nous allons créer un certificat valide à la fois pour les adresses www.server.com et webmail.server.com (directive <code>subjectAltName</code>).
Attention cependant, lors de la génération du certificat, pensez à définir le <code>commonName</code> à www.server.com
 
On génère la clé privé et la demande de certificat :
<pre>
openssl req -newkey rsa:4096 -sha256 -keyout cle-privee.key -out cle-publique.req
</pre>
Puis on signe le certificat. L'option <code>-name</code> permet de préciser qu'il faut utiliser l'autorité <code>core_ca</code> pour signer notre nouveau certificat :
<pre>
openssl ca -name core_ca -extensions SERVER_SSL -in cle-publique.req -out certificat.pem
</pre>
 
=Générer des certificats clients=
 
Ajoutez la section suivante dans votre fichier /etc/ssl/openssl.cnf :
<pre>
[CLIENT_SSL]
nsComment                      = "SSL Client Certificate"
subjectKeyIdentifier            = hash
authorityKeyIdentifier          = keyid,issuer:always
issuerAltName                  = issuer:copy
subjectAltName                  = critical,email:copy,email:root@server.com,email:admin@server.com
basicConstraints                = critical,CA:FALSE
keyUsage                        = critical,digitalSignature, nonRepudiation
nsCertType                      = client
extendedKeyUsage                = clientAuth
</pre>
 
La génération du couple de clé repose sur le même principe que pour un serveur.
 
=Révoquer un certificat=
 
Identifiez le certificat dans le fichier <code>/etc/ssl/core_ca/index.txt</code>. Par exemple, pour révoquer le certificat qui a l'identifiant 03 :
<pre>openssl ca -revoke /etc/ssl/core_ca/newcerts/03.pem</pre>
 
=Compatibilité avec la bibliothèque de certificats des distributions Linux=
 
Placez le certificat de votre CA dans /etc/ssl/certs/myca.pem puis lancez les commandes suivantes :
<pre>cd /etc/ssl/certs/
chmod o+r myca.pem
ln -s myca.pem `openssl x509 -hash -noout -in myca.pem`.0
cd
</pre>
</pre>
Pfoo
Bureaucrates, Administrateurs
4 203

modifications

Récupérée de « https://wiki.unscdf.org/index.php?title=Spécial:MobileDiff/36...3449 »

Menu de navigation