Création de sa propre autorité de certification

J’avais initialement prévu d’aborder dans un troisième article la configuration d’un serveur mail, mais il fallait d’abord que j’explique comment mettre en place une autorité de certification, puisque nous allons nous en servir dans la configuration du serveur mail, mais aussi pour bien d’autres services que nous verrons ultérieurement.

À l’issue de cet article, vous aurez à disposition une série de scripts qui vous permettront de mettre rapidement et facilement en place des certificats pour tous types d’applications.

L’autorité de certification et les certificats vous permettront de chiffrer les données qui vont transiter sur votre cloud personnel. Ainsi, si une personne malintentionnée cherchait à espionner ce qui transite entre votre propre machine et votre serveur, elle ne pourrait pas exploiter les données qu’elle récolterait. C’est une solution fiable, même si tout chiffrement peut être “cassé”. Il faut simplement garder à l’esprit que vous n’êtes pas une banque, et que les données que vous allez stocker sur votre serveur n’ont de valeur que pour vous. Personne ne cherchera donc à passer des semaines ou des mois à casser le chiffrement de vos certificats…

Notice : En revanche, ils seront bien utiles pour chiffrer les données qui transitent sur votre réseau.

Important : VeriSign

Créons tout d’abord un répertoire dédié à nos scripts :

mkdir -p /scripts/certificate_authority

Vérifions ensuite que nous disposons bien du paquet nécessaire :

apt-get install openssl

Nous allons créer les premiers certificats, matérialisant l’autorité de certification. Les certificats spécifiques à certains services seront signés par cette autorité. Pour commencer, on va se créer un fichier de configuration personnalisé :

cp /etc/ssl/openssl.cnf /scripts/certificate_authority/
cd /scripts/certificate_authority
nano openssl.cnf

On édite ce fichier pour y modifier les variables suivantes :

• Dans la catégorie [CA_default], mettez les valeurs suivantes :

dir             = /scripts/certificate_authority
certs           = $dir/
crl_dir         = $dir/
database        = $dir/index.txt

new_certs_dir   = $dir/

certificate     = $dir/ca.crt
serial          = $dir/current_serial
crlnumber       = $dir/current_crl
crl             = $dir/crl.pem
private_key     = $dir/ca.key
RANDFILE        = $dir/.rand

• Dans la catégorie [req_distinguished_name], renseignez les valeurs suivantes :

• countryName_default

• stateOrProvinceName_default

• localityName_default

• 0.organizationName_default

• emailAddress_default

Enregistrez puis fermez ce fichier. On va ensuite créer le fichier create_ca, qui aura pour but de créer l’autorité de certification. L’autorité de certification n’est à créer qu’une seule fois, mais le fait de créer un script pour le faire permettra, en cas de besoin, de retrouver les commandes nécessaires. À noter que nous allons créer un certificat dont la validité est de 10 ans (3650 jours).

nano create_ca

#!/bin/bash

base=`dirname $0`

echo "Étape 1 : Création de la clé"
openssl genrsa -des3 -out "$base/ca.key" 1024

echo "Étape 2 : Génération de la demande de certificat"
openssl req -config "$base/openssl.cnf" -new -key "$base/ca.key" -out "$base/ca.csr"

echo "Étape 3 : Génération du certificat"
openssl x509 -days 3650 -signkey "$base/ca.key" -in "$base/ca.csr" -req -out "$base/ca.crt"

chmod 0400 ca.key

chmod 700 create_ca

Cette dernière commande nous assure que personne à part root ne peut exécuter ce fichier. Ce que nous allons faire immédiatement :

./create_ca

Après vous avoir demandé un mot de passe (qu’il est impératif de renseigner), quelques questions vont vous être posées. La plupart contient déjà les réponses pré-replies dans le fichier openssl.cnf que nous avons édité plus tôt. Seule la variable Organizational Unit Name est à spécifier (mettez ce que vous voulez, par exemple “Certificate Authority”), et la variable Common Name, qui devrait contenir votre nom de domaine principal.

Une fois la commande exécutée et les variables spécifiées, trois nouveaux fichiers ont été créés dans le répertoire de travail (/scripts/certificate_authority) : ca.csr (la demande de certificat), ca.crt (le certificat principal) et ca.key (la clé privée). On peut désormais créer de nouveaux certificats, à l’aide d’un nouveau script :

nano make_request

#!/bin/bash

app=$1
domain=$2
base=`dirname $0`

if [ "$app" == "" ]
then
        echo "Vous devez spécifier un nom d'application ou de service"
        exit
fi

if [ "$domain" == "" ]
then
        echo "Vous devez spécifier un nom de domaine"
        exit
fi

if [ ! -d "$base/$app" ]
then
        mkdir "$base/$app"
fi

echo "Étape 1 : Création de la clé"
openssl genrsa -des3 -out "$base/$app/$domain.key" 1024

echo "Étape 2 : Création de la demande de certificat"
openssl req -config "$base/openssl.cnf" -new -key "$base/$app/$domain.key" -out "$base/$app/$domain.csr"

echo "Souhaitez-vous créer une clé sans mot de passe ? (o/n) [n]"

read answer

if [ $answer = o -o $answer = O ]
then
        cp "$base/$app/$domain.key" "$base/$app/$domain.key-withpass"
        openssl rsa -in "$base/$app/$domain.key-withpass" -out "$base/$app/$domain.key"
        chmod 0440 "$base/$app/$domain.key-withpass"
fi

chmod 0440 "$base/$app/$domain.key"

chmod +x ./make_request

L’objectif de ce script va être de générer une demande de certificat pour une application donnée et un domaine donné. Cela nous permettra de générer des certificats différents selon les applications et les domaines, mais il est tout à fait possible (bien que déconseillé) de générer un seul certificat et de s’en servir dans toutes nos applications. Ce script s’utilisera de la manière suivante :

./make_request <application> <domaine>

Ce script va également nous permettre de créer des clés sans mot de passe, ce qui sera utile avec apache.

Créons ensuite le script qui va nous permettre de demander la signature d’une demande précédente :

nano sign_request

#!/bin/bash

app=$1
domain=$2
base=`dirname $0`
serial=0

if [ "$app" == "" ]
then
        echo "Vous devez spécifier un nom d'application ou de service"
        exit
fi

if [ "$domain" == "" ]
then
        echo "Vous devez spécifier un nom de domaine"
        exit
fi

if [ ! -d "$base/$app" ]
then
        echo "Aucun certificat n'a été généré pour l'application spécifiée"
        exit
fi

if [ ! -f "$base/$app/$domain.csr" ]
then
        echo "Aucun certificat n'a été généré pour le domaine spécifié"
        exit
fi

if [ -f "$base/current_serial" ]
then
        serial=`cat "$base/current_serial"`
fi

serial=$(($serial+1))

openssl x509 -req -days 3650 -in "$base/$app/$domain.csr" -CA "$base/ca.crt" -CAkey "$base/ca.key" -set_serial $serial -out "$base/$app/$domain.crt"

echo "$serial" > "$base/current_serial"

echo "Souhaitez-vous supprimer la requête initiale ? ($domain.csr) (o/n) [o]"

read answer

if [ "$answer" != "n" -a "$ans" != "N" ]
then
        rm "$base/$app/$domain.csr"
fi

chmod 700 sign_request

La syntaxe est la même que précédemment :

./sign_request <application> <domaine>

La signature du certificat va générer un fichier portant l’extension .crt : c’est celui-ci qui sera notamment utilisé à travers les applications.

La procédure pour créer un certificat valide est donc la suivante. Nous admettrons pour l’exemple que nous travaillons avec apache.

./make_request apache exemple.fr
./sign_request apache exemple.fr

Cela aura pour conséquence de créer un répertoire apache dans le répertoire /scripts/certificate_authority, qui contiendra vos certificats, demandes, et clés spécifiques à apache.

Vous disposez désormais d’un ensemble complet d’outils pour générer facilement les certificats dont vous aurez besoin plus tard, et notamment lors de la mise en place du serveur mail, prochaine étape de la création de votre cloud personnel.