Modification de OpenSSL : Configuration

{{EnCours|auteur=Adadov}}
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.

OpenSSL est une implémentation libre du protocole ssl et permet de créer facilement des couples de clés publique / privée.

Nous allons voir comment créer un autorité de certification racine (root), une autorité intermédiaire, et enfin, un couple de clé pouvant être utilisé par exemple pour apache.

Les changements de permissions effectués dans ce howto supposent que vous êtes en umask 0027

=Installation et généralités=

Pour installer openssl utilisez aptitude :
<pre>aptitude install openssl</pre>

Attention : certains paquets peuvent avoir besoin d'accéder au fichier <code>/etc/ssl/openssl.cnf</code> (c'est par exemple le cas de bind9 depuis une mise à jour de sécurité). Veillez donc à ce que ce fichier reste accessible en lecture pour other.

Le programme openssl fonctionne de la manière suivante :
<pre>openssl <comande> [options]</pre>

Par exemple, la commande <code>ca</code> gère les autorités de certification, la commande <code>req</code> gère les requêtes de certificat, ...

Voici les principales directives utilisés pour des certificats ssl :

* basicConstraints
** <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.
* keyUsage
** digitalSignature (RSA/DSA) : pour la signature en tant que méthode de chiffrement
** nonRepudiation (RSA/DSA) : pour la signature en tant que service
** keyEncipherment (RSA) : chiffrement de clé (privé)
** dataEncipherment (RSA) : chiffrement de données
** keyCertSign (RSA/DSA) : signature de certificats (utilisé pour les AC)
** cRLSign (RSA/DSA) : signature de listes de révocation (encore une fois utile pour les AC)
** keyAgreement (DH) : pour la négociation d'une clé de session
** encipherOnly et decipherOnly (DH) : à préciser en même temps que keyAgreement
* nsCertType
** client ou server : pour une authentification ou du chiffrement client / serveur selon le cas
** email : chiffrement de mails en S/MIME
** objsign : signature de code
** sslCA, emailCA, objCA : pour délivrer des autorités de certifications ayant les propriétés client/serveur, email ou obj
* extendedKeyUsage
** serverAuth : à utiliser en même temps que un nsCertType server
** clientAuth : à utiliser en même temps que un nsCertType client
** codeSigning : à utiliser en même temps que un nsCertType objsign
** emailProtection : à utiliser en même temps que un nsCertType email
* subjectAltName : à utiliser pour utiliser le même certificat sur plusieurs sites webs différents (name-based virtual host de apache), ou encore pour des adresses mails associés au même certificat

=Mise en place d'une autorité de certification=

Pour commencer il faut créer une arborescence pour l'AC dans /etc/ssl/. Nous allons créer les arborescences suivante :
<pre>
    root_ca/
    |-- certs/
    |-- crl/
    |-- newcerts/
    |-- private/
    |-- serial
    |-- index.txt
</pre>
et
<pre>
    core_ca/
    |-- certs/
    |-- crl/
    |-- newcerts/
    |-- private/
    |-- serial
    |-- index.txt
</pre>

Exécutez les commandes suivantes :
<pre>
mkdir -p /etc/ssl/root_ca/{certs,crl,newcerts,private}
mkdir -p /etc/ssl/core_ca/{certs,crl,newcerts,private}
touch /etc/ssl/root_ca/index.txt
touch /etc/ssl/core_ca/index.txt
echo 01 > /etc/ssl/root_ca/serial
echo 01 > /etc/ssl/core_ca/serial
</pre>

==le fichier /etc/openssl.cnf==
Ensuite nous allons configurer <code>/etc/ssl/openssl.cnf</code> pour qu'il reconnaisse cette arborescence.
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 :

<pre>
[ ca ]
#Cette section nous permet de définir l'autorité de certification par défaut.
default_ca      = root_ca

#l'autorité de certification racine (root) valable 10 ans
[ root_ca ]
dir             = /etc/ssl/root_ca
certs           = $dir/certs
new_certs_dir   = $dir/newcerts
database        = $dir/index.txt
certificate     = $dir/root_ca.pem
serial          = $dir/serial
private_key     = $dir/private/root_ca.key
default_days    = 3650
default_md      = sha1
preserve        = no
policy          = policy_match

#l'autorité de certification intermédiaire valable 10 ans
[ core_ca ]
dir             = /etc/ssl/core_ca
certs           = $dir/certs  
new_certs_dir   = $dir/newcerts
database        = $dir/index.txt
certificate     = $dir/core_ca.pem 
serial          = $dir/serial
private_key     = $dir/private/core_ca.key
default_days    = 3650
default_md      = sha1
preserve        = no  
policy          = policy_match
</pre>

Vous pouvez laisser les sections [ policy_match ] et [ policy_anything ] telle quelle :
<pre>
[ policy_match ]
countryName             = match
stateOrProvinceName     = match
localityName		= match
organizationName        = match
organizationalUnitName  = optional
commonName              = supplied
emailAddress            = optional

[ policy_anything ]
countryName             = optional
stateOrProvinceName     = optional
localityName            = optional
organizationName        = optional
organizationalUnitName  = optional
commonName              = supplied
emailAddress            = optional
</pre>

Les sections [ req ] et [ req_distinguished_name ] définissent les paramètres par défaut pour la création d'un certificat ssl :
<pre>
[ req ]
default_bits            = 2048
distinguished_name      = req_distinguished_name

[ req_distinguished_name ]
countryName                     = Country Name (2 letter code)
countryName_default             = FR
countryName_min                 = 2
countryName_max                 = 2
stateOrProvinceName             = State or Province Name (full name)
stateOrProvinceName_default     = Alsace
localityName                    = Locality Name (eg, city)
localityName_default            = Strasbourg
0.organizationName              = Organization Name (eg, company)
0.organizationName_default      = CSNU
# we can do this but it is not needed normally :-)
#1.organizationName             = Second Organization Name (eg, company)
#1.organizationName_default     = World Wide Web Pty Ltd
organizationalUnitName          = Organizational Unit Name (eg, section)
#organizationalUnitName_default =
commonName                      = Common Name (eg, YOUR name)
commonName_max                  = 64
emailAddress                    = Email Address
emailAddress_max                = 64

[ req_attributes ]
challengePassword               = A challenge password
challengePassword_min           = 4
challengePassword_max           = 20
unstructuredName                = An optional company name
</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>
[ROOT_CA]
nsComment                       = "ROOT CA"
subjectKeyIdentifier            = hash
authorityKeyIdentifier          = keyid,issuer:always
basicConstraints                = critical,CA:TRUE,pathlen:1
keyUsage                        = keyCertSign, cRLSign

[CORE_CA]
nsComment                       = "SSL CA"
basicConstraints                = critical,CA:TRUE,pathlen:0
subjectKeyIdentifier            = hash
authorityKeyIdentifier          = keyid,issuer:always
issuerAltName                   = issuer:copy
keyUsage                        = keyCertSign, cRLSign
nsCertType                      = sslCA
</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==
Maintenant nous pouvons créer le certificat de l'autorité de certification :
<pre>
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
</pre>

Quelques explications :
* 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.
* -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.
* -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.
* -keyout défini le chemin où sera stocké la clé privée.
* -out désigne le chemin où sera stocké la clé publique.

Le mot de passe (<code>PEM pass phrase</code>) doit être assez compliqué étant donné que ce couple de clé assure la validité de tous les certificats qui seront signés avec lui. Si la clé privé de l'AC est compromise, c'est tous les certificats signés par l'AC qui sont compromis.

Pour s'assurer de la sécurité de la clé privée :
<pre>
chmod -R 600 /etc/ssl/root_ca/private
</pre>

==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>
cd /etc/ssl/core_ca
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.
Notez qu'on précise qu'il faut configurer ce nouveau certificat en utilisant la section CORE_CA du fichier de configuration.
<pre>
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'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:2048 -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                        = 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:2048 -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                        = 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=

<pre>openssl ca -revoke blah.pem</pre>
[[Category:SysAdmin]]
[[Category:security]]