Serveur web APACHE et authentification SSL

Ce tutoriel décrit les techniques de configuration du module Apache SSL, qui étend les fonctionnalités du serveur Web Apache pour prendre en charge le protocole SSL. Le tutoriel traitera de l’authentification du serveur (authentification SSL unidirectionnelle), ainsi que de l’authentification des clients à l’aide de certificats (authentification SSL bidirectionnelle).

Dans ce tutoriel, vous allez apprendre :

Comment fonctionne l’authentification SSL ?
Comment configurer l’authentification SSL unidirectionnelle
Comment configurer l’authentification SSL bidirectionnelle
Comment générer un certificat SSL
Comment importer une autorité de certification dans un navigateur web

Comment fonctionne l’authentification SSL ?

Si vous avez décidé d’activer le protocole SSL (Secure Sockets Layer) sur votre serveur web, c’est peut-être parce que vous souhaitez étendre ses fonctionnalités pour atteindre une intégrité et une confidentialité pour des données transférées sur des réseaux non sécurisés. Cependant, ce protocole avec la combinaison des principes de l’infrastructure à clé publique (PKI) peut également, en plus de l’intégrité et de la confidentialité, fournir une authentification entre les deux parties impliquées dans la communication client-serveur.

L’authentification SSL unidirectionnelle permet à un client SSL de confirmer l’identité du serveur SSL. Cependant, le serveur SSL ne peut pas confirmer l’identité du client SSL. Ce type d’authentification SSL est utilisé par le protocole HTTPS et de nombreux serveurs publics à travers le monde fournissent ainsi des services tels que le webmail ou la banque en ligne.

L’authentification du client SSL s’effectue sur une « couche applicative » du modèle OSI par le client en saisissant des identifiants d’authentification tels que le nom d’utilisateur et le mot de passe ou en utilisant une carte de grille.

L’authentification SSL bidirectionnelle, également connue sous le nom d’authentification SSL mutuelle, permet au client SSL de confirmer l’identité du serveur SSL, et le serveur SSL peut également confirmer l’identité du client SSL. Ce type d’authentification est appelé authentification client, car le client SSL montre son identité au serveur SSL à l’aide du certificat client.

L’authentification du client avec un certificat peut ajouter une couche supplémentaire de sécurité ou même remplacer complètement les méthodes d’authentification telles que le nom d’utilisateur et le mot de passe.

Dans les sections suivantes de ce tutoorial, nous aborderons la configuration des deux types d’authentification SSL : l’authentification SSL unidirectionnelle et l’authentification SSL bidirectionnelle.

Émission de certificats OpenSSL

Cette section décrit brièvement une procédure permettant de créer tous les certificats requis à l’aide d’une application openssl. L’ensemble du processus d’émission de certificats openssl est simple. Cependant, dans le cas où un plus grand nombre de certificats émis est requis, la procédure décrite ci-dessous serait inadéquate, et par conséquent, je recommande dans ce cas d’utiliser le module CA d’OpenSSL.

NOTE
Le lecteur doit avoir une connaissance de base de l’ICP, et pour cette raison, toutes les étapes seront décrites brièvement. Veuillez suivre ce lien si vous souhaitez rafraîchir vos connaissances sur l’infrastructure à clé publique.

Tous les certificats seront émis à l’aide de l’application OpenSSL et du fichier de configuration openssl.cnf. Veuillez enregistrer ce fichier dans un répertoire à partir duquel vous exécuterez toutes les commandes openssl. Veuillez noter que ce fichier de configuration est facultatif et que nous l’utilisons uniquement pour faciliter l’ensemble du processus.

[ req ]
default_md = sha1
distinguished_name = req_distinguished_name

[ req_distinguished_name ]
countryName = Country
countryName_default = SK
countryName_min = 2
countryName_max = 2
localityName = Locality
localityName_default = Bratislava
organizationName = Organization
organizationName_default = Linuxconfig Enterprises
commonName = Common Name
commonName_max = 64

[ certauth ]
subjectKeyIdentifier = hash
authorityKeyIdentifier = keyid:always,issuer:always
basicConstraints = CA:true
crlDistributionPoints = @crl

[ server ]
basicConstraints = CA:FALSE
keyUsage = digitalSignature, keyEncipherment, dataEncipherment
extendedKeyUsage = serverAuth
nsCertType = server
crlDistributionPoints = @crl

[ client ]
basicConstraints = CA:FALSE
keyUsage = digitalSignature, keyEncipherment, dataEncipherment
extendedKeyUsage = clientAuth
nsCertType = client
crlDistributionPoints = @crl

[ crl ]
URI=http://testca.local/ca.crl

Dans un premier temps, vous devez générer une autorité de certification de certificat auto-signée. Une fois qu’on vous a demandé la valeur de « Nom commun », insérez la chaîne « Test CA » :
```
openssl req -config ./openssl.cnf -newkey rsa:2048 -nodes -keyform PEM -keyout ca.key -x509 -days 3650 -extensions certauth -outform PEM -out ca.cer
```

Si vous n’avez rencontré aucune complication lors de l’exécution de la commande ci-dessus, vous trouverez dans votre répertoire actuel un fichier contenant ca.key clé privée de l’autorité de certification (CA) et ca.cer avec son certificat auto-signé.

À l’étape suivante, vous devez générer une clé SSL privée pour le serveur :
```
openssl genrsa -out server.key 2048
```
Pour générer une demande de signature de certificat au format PKCS#10, vous devez utiliser une commande linux suivante comme nom commun, vous pouvez spécifier son nom d’hôte - par exemple « localhost ».
```
openssl req -config ./openssl.cnf -new -key server.key -out server.req
```

Avec une autorité de certification auto-signée, émettez un certificat de serveur avec le numéro de série 100 :

openssl x509 -req -in server.req -CA ca.cer -CAkey ca.key -set_serial 100 -extfile openssl.cnf -extensions server -days 365 -outform PEM -out server.cer

Le nouveau fichier server.key contient la clé privée du serveur et le fichier server.cer est un certificat lui-même. Le fichier de demande de signature de certificat server.req n’est plus nécessaire et peut donc être supprimé.
```
rm server.req
```
Clé privée génératrice pour le client SSL :
```
openssl genrsa -out client.key 2048
```
En ce qui concerne le serveur, vous devez également générer une demande de signature de certificat et comme nom commun, j’ai utilisé la chaîne de caractères : « Linuxconfig.org « .
```
openssl req -config ./openssl.cnf -new -key client.key -out client.req
```

Avec votre autorité de certification auto-signée, émettez un certificat client avec le numéro de série 101 :

openssl x509 -req -in client.req -CA ca.cer -CAkey ca.key -set_serial 101 -extfile openssl.cnf -extensions client -days 365 -outform PEM -out client.cer

Enregistrez la clé privée et le certificat du client au format PKCS#12. Ce certificat sera sécurisé par un mot de passe et ce mot de passe sera utilisé dans les sections suivantes pour importer le certificat dans le gestionnaire de certificats du navigateur Web :
```
openssl pkcs12 -export -inkey client.key -in client.cer -out client.p12
```
Le fichier client.p12 contient une clé privée et le certificat du client, donc les fichiers client.key, client.cer et client.req ne sont plus nécessaires, donc ces fichiers peuvent être supprimés.
```
rm client.key client.cer client.req
```

Authentification SSL unidirectionnelle

Une fois que la clé privée et le certificat du serveur sont prêts, vous pouvez commencer la configuration SSL du serveur Web Apache. Dans de nombreux cas, ce processus est composé de 2 étapes : l’activation de mod_ssl et la création d’un hôte virtuel pour le port 443/TCP.

L’activation de mod_ssl est très simple, tout ce que vous avez à faire est d’exécuter les commandes suivantes :
```
a2enmod ssl
systemctl restart
```

Vous pouvez copier et coller le fichier de configuration Apache suivant, et soit le garder tel quel, soit apporter les modifications nécessaires que vous jugez appropriées.

<VirtualHost _default_:443>
       ServerAdmin webmaster@localhost

        DocumentRoot /var/www
        
                Options FollowSymLinks
                Options Indexes FollowSymLinks MultiViews

        ScriptAlias /cgi-bin/ /usr/lib/cgi-bin/
        
                Options +ExecCGI -MultiViews +SymLinksIfOwnerMatch

        LogLevel warn
        ErrorLog /var/log/apache2/error.log
        CustomLog /var/log/apache2/ssl_access.log combined

        SSLEngine on
        SSLCertificateFile    /etc/apache2/ssl/server.cer
        SSLCertificateKeyFile /etc/apache2/ssl/server.key

</VirtualHost>

Dans l’exemple ci-dessus, la directive SSLEngine on active la prise en charge de l’hôte virtuel SSL. La directive SSLCertificateFile définit un chemin complet du certificat du serveur et enfin la directive SSLCertificateKeyFile définit un chemin complet vers la clé privée du serveur. Si la clé privée est sécurisée par un mot de passe, ce mot de passe ne sera nécessaire que lors du démarrage du serveur web apache.

Toute modification du fichier https.conf, telle que les modifications ci-dessus, nécessite un redémarrage du serveur Web. Si vous rencontrez des problèmes lors du redémarrage, il est probable que cela soit dû à des erreurs de configuration dans votre fichier de configuration Apache. L’erreur réelle devrait apparaître dans le journal des erreurs de deamon. N’oubliez pas de déplacer d’abord vos fichiers SSL dans le répertoire approprié.
```
mkdir -p /etc/apache2/ssl
mv server.cer server.key /etc/apache2/ssl
systemctl restart apache2
```
Le test d’une fonctionnalité de notre nouvelle configuration peut être effectué à l’aide d’un navigateur Web. La première tentative de connexion affiche très certainement un message d’erreur, indiquant que la tentative de vérification du certificat du serveur a échoué car l’émetteur du certificat est inconnu.
L’importation du certificat de l’autorité de certification dans le navigateur Web à l’aide de son gestionnaire de certificats résoudra ce problème. Pour ajouter un certificat dans un navigateur Mozilla Firefox, accédez à Configurations > Certificats de confidentialité et de sécurité > > Afficher les certificats.
Assurez-vous de cocher la case « Faire confiance à cette autorité de certification pour identifier les sites Web » pendant le processus.
La prochaine tentative de connexion au serveur Web devrait réussir.

Si vous voulez éviter d’avoir à importer le certificat d’une autorité de certification dans le navigateur Web, vous pouvez acheter un certificat de serveur auprès d’une autorité commerciale, dont les certificats sont distribués par le navigateur Web.

Authentification SSL bidirectionnelle

Si vous avez décidé d’exiger une authentification par certificat de chaque client, il vous suffit d’ajouter les lignes suivantes dans un fichier de configuration d’hôte virtuel :
```
SSLVerifyClient require
SSLVerifyDepth 10
SSLCACertificateFile /etc/apache2/ssl/ca.cer
```
La directive SSLVerifyClient require garantit que les clients qui ne fournissent pas de certificat valide de certaines autorités de certification de confiance ne pourront pas communiquer avec le serveur SSL. Certaines autorités de certification s’appuient sur une autre autorité de certification, qui peut encore s’appuyer sur une autre et ainsi de suite.
La directive SSLVerifyDepth 10 spécifie jusqu’à quel point dans la chaîne de dépendance à l’autorité de certification, le serveur acceptera le certificat signé par l’autorité de certification comme valide. Si, par exemple, la directive SSLVerifyDepth contient la valeur 1, le certificat du client doit être signé directement par votre autorité de certification de confiance. Dans cet article, le certificat du client est signé directement par l’autorité de certification et la seule valeur raisonnable pour la directive SSLVerifyDepth est donc 1.

La dernière directive SSLCACertificateFile spécifie un chemin d’accès complet à un certificat d’autorité de certification par lequel le certificat d’un client a été signé.

N’oubliez pas de redémarrer votre serveur web apache après toute modification apportée à ses fichiers de configuration :
```
systemctl restart apache2
```
Si vous essayez de vous connecter au serveur SSL sans certificat client, un message d’erreur s’affiche :
Tout ce qu’il faut faire est d’importer un certificat client précédemment créé sous forme PKCS#12 dans le gestionnaire de certificats de Firefox dans la section « Vos certificats ». Cette tâche peut être effectuée en accédant au menu, puis à Paramètres, > Confidentialité et sécurité > Certificats > Afficher les certificats.
Lors de l’importation, il vous sera demandé de saisir un mot de passe qui avait été défini lors de la création du certificat. Selon la version du navigateur que vous utilisez, vous devrez peut-être également définir le mot de passe principal du jeton logiciel, qui est utilisé par le navigateur pour stocker en toute sécurité les certificats.
Si vous tentez à nouveau de vous connecter au serveur SSL, le navigateur affichera automatiquement un certificat approprié pour l’authentification du serveur SSL. Après la sélection d’un certificat valide, la connexion au serveur SSL sera accordée.

Réflexions finales

Si vous n’avez pas encore entendu parler de l’authentification SSL bidirectionnelle, il est probable qu’après avoir lu cet article, vous vous soyez demandé pourquoi ce type d’authentification SSL n’est pas souvent utilisé dans l’environnement de production. La réponse est simple : les opérations cryptiques utilisées lors des connexions SSL sont difficiles à traiter en ce qui concerne les ressources du serveur Web.