EJBCA - Installation d'une infrastructure à clés publiques (PKI)

Création — Nicolas THOREZ 2024/03/19 10:29
Modification — Nicolas THOREZ 2024/03/26 16:26

Une infrastructure à clés publiques ou PKI (Public Key Infrastructure) est un ensemble de services permettant de gérer des clés publiques et se faisant, permettant l'authentification d'un service, système ou utilisateur.

Réf : Wikipédia

Dans cette procédure, nous allons voir la mise en place d'une PKI via le logiciel EJBCA (Enterprise JavaBeans Certificate Authority) en version Community.

Réf : EJBCA

• On installe les paquets de prérequis :

apt install -y ca-certificates curl

• On ajoute le dépôt de docker :

install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc
chmod a+r /etc/apt/keyrings/docker.asc
echo \
"deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/debian \
$(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
tee /etc/apt/sources.list.d/docker.list > /dev/null

• On installe les paquets nécessaires :

apt update
apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

• On créé et on va dans l'arborescence du projet :

mkdir -p /opt/ejbca/containers/datadbdir
cd /opt/ejbca/containers/

• On crée le fichier de configuration pour le docker :

nano docker-compose.yml

version: '3'
networks:
  access-bridge:
    driver: bridge
  application-bridge:
    driver: bridge
services:
  ejbca-database:
    container_name: ejbca-database
    image: "library/mariadb:latest"
    networks:
      - application-bridge
    environment:
      - MYSQL_ROOT_PASSWORD=foo123
      - MYSQL_DATABASE=ejbca
      - MYSQL_USER=ejbca
      - MYSQL_PASSWORD=ejbca
    volumes:
      - ./datadbdir:/var/lib/mysql:rw
  ejbca-node1:
    hostname: ejbca-node1
    container_name: ejbca
    image: keyfactor/ejbca-ce:latest
    depends_on:
      - ejbca-database
    networks:
      - access-bridge
      - application-bridge
    environment:
      - DATABASE_JDBC_URL=jdbc:mariadb://ejbca-database:3306/ejbca?characterEncoding=UTF-8
      - LOG_LEVEL_APP=INFO
      - LOG_LEVEL_SERVER=INFO
      - TLS_SETUP_ENABLED=simple
    ports:
      - "80:8080"
      - "443:8443"

• On prendra soin de personnaliser MYSQL_ROOT_PASSWORD (le mot de passe pour la base de données de la PKI).
• Une fois enregistré, on peut lancer la création du docker :

docker compose up -d

• La commande suivante permet de voir l'état d'initialisation de l'instance. Une fois terminée, les logs affiche l'adresse pour la configuration via l'interface web :

docker compose logs -f

• Retour console :

ejbca           | 2024-03-19 12:51:19,457+0000 INFO  [/opt/keyfactor/bin/start.sh] (process:1) Waiting 5 seconds before signaling application readiness to ensure proper handling of PublicAccessAuthenticationToken.
ejbca           | 2024-03-19 12:51:24,471+0000 INFO  [/opt/keyfactor/bin/start.sh] (process:1) Health check now reports application status at /ejbca/publicweb/healthcheck/ejbcahealth
ejbca           | 2024-03-19 12:51:24,484+0000 INFO  [/opt/keyfactor/bin/start.sh] (process:1) *****************************************************************************************
ejbca           | 2024-03-19 12:51:24,484+0000 INFO  [/opt/keyfactor/bin/start.sh] (process:1) *                                                                                       *
ejbca           | 2024-03-19 12:51:24,484+0000 INFO  [/opt/keyfactor/bin/start.sh] (process:1) * A fresh installation was detected and a ManagementCA was created for your initial     *
ejbca           | 2024-03-19 12:51:24,484+0000 INFO  [/opt/keyfactor/bin/start.sh] (process:1) * access to the system.                                                                 *
ejbca           | 2024-03-19 12:51:24,484+0000 INFO  [/opt/keyfactor/bin/start.sh] (process:1) *                                                                                       *
ejbca           | 2024-03-19 12:51:24,484+0000 INFO  [/opt/keyfactor/bin/start.sh] (process:1) *   URL:      https://ejbca-node1:443/ejbca/adminweb/                                   *
ejbca           | 2024-03-19 12:51:24,484+0000 INFO  [/opt/keyfactor/bin/start.sh] (process:1) *                                                                                       *
ejbca           | 2024-03-19 12:51:24,484+0000 INFO  [/opt/keyfactor/bin/start.sh] (process:1) * If you use different port mapping or a proxy, please adapt the URL above accordingly. *
ejbca           | 2024-03-19 12:51:24,484+0000 INFO  [/opt/keyfactor/bin/start.sh] (process:1) *                                                                                       *
ejbca           | 2024-03-19 12:51:24,484+0000 INFO  [/opt/keyfactor/bin/start.sh] (process:1) *****************************************************************************************

Pour gérer plus facilement l'état de l'instance (démarrage, redémarrage, arrêt, status), j'ai créé le script suivant :

touch /opt/ejbca/manage-ejbca-daemon.sh
chmod +x /opt/ejbca/manage-ejbca-daemon.sh
nano /opt/ejbca/manage-ejbca-daemon.sh

#!/bin/bash

##########################################
#                                        #
#   Script de gestion du service EJBCA   #
#                                        #
##########################################

#===========#
# Variables #
#===========#

# Dossier de travail
WRKDIR=/opt/ejbca/containers

# Nom de l'instance ebjca
EJBCA=ejbca

# Nom de l'instance ebjca-database
EJBDB=ejbca-database

#===========#
# Fonctions #
#===========#

# Demande d'aide
get-help() {
        echo "Script de gestion du service EJBCA"
        echo ""
        echo "Usage : ./manage-ejbca-daemon.sh [backup|help|restart|start|status|stop|upgrade]"
        echo ""
        echo "backup                    Sauvegarde la base de données."
        echo "help                      Affiche cette aide."
        echo "restart                   Redémarre l'instance."
        echo "start                     Démarre l'instance."
        echo "status                    Affiche l'état de l'instance."
        echo "stop                      Arrête l'instance."
        echo "upgrade                   Met à jour l'instance."
}

#=======================#
# Gestion des arguments #
#=======================#

case $1 in
        "start"|"restart"|"stop"|"status"|"upgrade"|"backup")
                ACTION="$1"
                ;;
        "help")
                get-help
                exit 0
                ;;
        *)
                echo "Erreur : Argument $1 inconnu"
                echo ""
                get-help
                exit 2
                ;;
esac

#============#
# Traitement #
#============#

EJBCA_STATUS=$(docker container inspect -f '{{.State.Running}}' $EJBCA 2>&1)
EJBDB_STATUS=$(docker container inspect -f '{{.State.Running}}' $EJBDB 2>&1)

if [ "$EJBCA_STATUS" == "true" -a "$EJBDB_STATUS" == "true" ]; then
        STATUS=0
elif [ "$EJBCA_STATUS" == "true" -a "$EJBDB_STATUS" != "true" ]; then
        STATUS=1
elif [ "$EJBCA_STATUS" != "true" -a "$EJBDB_STATUS" == "true" ]; then
        STATUS=2
else
        STATUS=3
fi

case $ACTION in
        "start")
                # Vérification de l'état et action
                case $STATUS in
                        0)
                                # Démarré
                                echo "Instance déjà démarré"
                                CODE=1
                                ;;
                        1|2)
                                # Partiel
                                echo "Redémarrage de l'instance"
                                cd $WRKDIR && docker compose restart
                                CODE=0
                                ;;
                        3)
                                # Arrêté
                                echo "Démarrage de l'instance"
                                cd $WRKDIR && docker compose up -d
                                CODE=0
                                ;;
                        *)
                                # Autre
                                echo "Erreur status : $STATUS"
                                CODE=3
                                ;;
                esac
                ;;
        "stop")
                # Vérification de l'état et action
                case $STATUS in
                        0|1|2)
                                # Démarré
                                echo "Arrêt de l'instance"
                                cd $WRKDIR && docker compose down
                                CODE=0
                                ;;
                        3)
                                # Arrêté
                                echo "Instance déjà à l'arrêt"
                                CODE=1
                                ;;
                        *)
                                # Autre
                                echo "Erreur status : $STATUS"
                                CODE=3
                                ;;
                esac
                ;;
        "restart")
                # Vérification de l'état et action
                case $STATUS in
                        0)
                                # Démarré
                                echo "Redémarrage de l'instance"
                                cd $WRKDIR && docker compose restart
                                CODE=0
                                ;;
                        1|2)
                                # Partiel
                                echo "Instance partiellement démarrée, redémarrage complet..."
                                cd $WRKDIR && docker compose down && docker compose up -d
                                CODE=1
                                ;;
                        3)
                                # Arrêt
                                echo "Instance à l'arrêt, démarrage..."
                                cd $WRKDIR && docker compose up -d
                                CODE=1
                                ;;
                        *)
                                # Autre
                                echo "Erreur status : $STATUS"
                                CODE=3
                                ;;
                esac
                ;;
        "status")
                # Vérification de l'état et action
                case $STATUS in
                        0)
                                # Démarré
                                echo "Autorité de certification et base de données actives"
                                CODE=0
                                ;;
                        1)
                                # Base de données à l'arrêt
                                echo "Autorité de certification active mais la base de données est à l'arrêt"
                                CODE=1
                                ;;
                        2)
                                # Authorité à l'arrêt
                                echo "Base de données active mais l'autorité de certification est à l'arrêt"
                                CODE=1
                                ;;
                        3)
                                # Arrêt
                                echo "Autorité de certification et base de données à l'arrêt"
                                CODE=2
                                ;;
                        *)
                                # Autre
                                echo "Erreur status : $STATUS"
                                CODE=3
                                ;;
                esac
                ;;
        "backup")
                # Vérification de l'état et action
                case $STATUS in
                        0)
                                # Démarré
                                echo "Sauvegarde en cours..."
                                Version=$(curl -k -s https://localhost/ejbca/ejbca-rest-api/v1/certificate/status | jq .revision | awk '{print $2}')
                                UserName=$(grep 'MYSQL_USER' $WRKDIR/docker-compose.yml | cut -d'=' -f2)
                                PassWord=$(grep 'MYSQL_PASSWORD' $WRKDIR/docker-compose.yml | cut -d'=' -f2)
                                cd $WRKDIR && docker compose exec $EJBDB mysqldump ejbca -u${UserName} -p${PassWord} > ejbca-${Version}-backup-$(date +%Y%m%d_%H%M_%Z).sql
                                if [[ $? -eq 0 ]]; then
                                        # Sauvegarde réussie
                                        echo "Sauvegarde réussie"
                                        CODE=0
                                else
                                        # Sauvegarde raté
                                        echo "Sauvegarde en échec"
                                        CODE=2
                                fi
                                ;;
                        *)
                                # Autres
                                echo "L'instance n'est pas correctement démarrée. Sauvegarde impossible."
                                CODE=2
                                ;;
                esac
                ;;
        "upgrade")
                # On arrête l'instance
                echo "Arrêt de l'instance"
                cd $WRKDIR && docker compose down

                # Mise à jour
                echo "Téléchargement de la dernière version"
                cd $WRKDIR && docker image pull keyfactor/ejbca-ce:latest

                # Redémarrage de l'instance
                echo "Redémarrage et mise à jour"
                cd $WRKDIR && docker compose up -d
                ;;
        *)
                # Autre
                echo "Erreur action : $ACTION"
                CODE=3
                ;;
esac

#========#
# Sortie #
#========#

exit $CODE

Pour que l'instance démarre automatiquement au démarrage de la VM, on édite alors la crontab de root :

crontab -e

Et on ajoute la ligne suivante :

@reboot         /opt/ejbca/manage-ejbca-daemon.sh start

• Lors de la 1^ère connexion à l'interface, il est possible que votre navigateur vous propose d'envoyer un certificat pour l'authentification. Il faudra décocher la case Se souvenir de cette décision et refuser cet envoi. Ce message peut revenir plusieurs fois tant que l'authentification n'est pas paramétrée :

• Pour créer un compte admin, on ira dans RA Web :

• Dans la nouvelle fenêtre, on ira dans la section Request new certificate et on cliquera sur Make New Request :

• Dans la section Select Request Template, on choisit les options suivantes :
  • Certificate subtype : ENDUSER (default)
  • Key-pair generation : By the CA

• Dans la section Select key algorithm, on choisira :
  • Key algorithm : RSA 2048 bits

• Dans la section Provide request info, on entre les informations :
  • CN, Common Name : on entre le nom du compte administrateur.
  • Key Recoverable : on décoche le case.

• Dans la section Provide User Credentials, on entre les informations :
  • Username : Le nom de du compte administrateur.
  • Enrollment code : Le mot de passe permettant d'enregistrer le certificat.
  • Confirm enrollment code : On confirme le mot de passe précédent.
  • Email : L'adresse mail associé à ce compte d'administration.

• Finalement, dans la section Confirm request, on trouvera le résumé de nos paramétrages et on pourra télécharger le certificat en cliquant sur Download PKCS#12 :

• Maintenant, il faut importer le certificat dans le navigateur. Pour Firefox, on ira donc dans le menu Paramètres puis Vie privée et sécurité et enfin Afficher les certificats… :

• Dans le gestionnaire de certificats, on sélectionne Vos certificats et on clique sur Importer… :

• On choisit le certificat créé, on entre le mot de passe de l'enregistrement et on clique sur Connexion :

• On peut vérifier la présence du nouveau certificat dans la liste et on sort du gestionnaire.

• On retourne sur l'interface d'administration de EJBCA et on clique sur Roles and Access Rules :

• On supprime Public Access Role et on édite les membres de Super Administrator Role en cliquant sur Members :

• On paramètre :
  • Match with : On sélectionne X509: CN, Common name.
  • CA : On choisit ManagementCA.
  • Match Value : On entre le nom du compte administrateur tel qu'il a été entré dans le champs CN, Common Name lors de la création du certificat. Attention, ce champs est sensible à la casse.
  • Description : Optionnel, cela permet d'identifier plus facilement le compte.
• Une fois les paramètres réglés, on valide en cliquant sur Add :

• On redémarre l'instance et on attend son démarrage complet :

/opt/ejbca/manage-ejbca-daemon.sh restart
cd /opt/ejbca/containers/ && docker compose logs -f | grep 'Health ckeck now reports application'

• On ferme le navigateur pour vider le cache et on se reconnecte sur l'interface d'administration et lors de la demande d'envoi de certificat, on choisit le certificat créé.

• On retourne sur l'interface d'administration, dans Roles and Access Rules, et Members de Super Administrator Role.
• On supprime PublicAccessAuthenticationToken :

Si on souhaite interagir avec les autorités de certifications via API (pour de l'automatisation par exemple), il convient de le configurer le service et l'utilisateur au niveau de l'interface d'administration :

• On va dans System Configuration, Protocol Configuration et on active REST Certificate Management avec le bouton Enable :

• On va commencer par créer un certificat utilisateur, qu'on appellera script, comme on l'a fait pour l'administrateur.
• Une fois en possession du certificat, on va dans Roles and Access Rules et on crée un rôle en cliquant sur Add :

• On nomme notre rôle et on clique sur Add :

• On édite les droits pour ce nouveau rôle en cliquant sur Access Rules :

• On va directement dans Advanced Mode :

• On modifie les puces suivantes :

• On n'oublie pas de sauvegarder les droits en cliquant sur Save en bas de page.
• On retourne sur notre liste de rôle et on clique sur Members :

• Comme précédemment pour le compte administrateur, on paramètre :
  • Match with : On sélectionne X509: CN, Common name.
  • CA : On choisit ManagementCA.
  • Match Value : On entre le nom du compte utilisateur, à savoir script dans notre cas.
  • Description : Optionnel, cela permet d'identifier plus facilement le compte.
• On ajoute le compte en cliquant sur Add :

Pour la supervision dans Nagios, nous allons contrôler 4 éléments :

• L'état du service docker.
• L'état des différents containers.
• L'état de santé de la PKI.
• La présence de mises à jour.

Ci-dessous, je dépose les scripts que j'utilise pour les différents contrôles

On se base sur les plugins de nagios avec la commande :

/usr/lib/nagios/plugins/check_procs -w 1:1 -c 0: -C dockerd

J'utilise le script de Tim Laurence (Source : GitHub) pour contrôler l'état des containers. Une fois le script installé, il suffit de lancer la commande suivante :

/usr/lib/nagios/plugins/check_docker.py --no-ok --status running --containers ejbca ejbca-database

La PKI réalise une vérification automatique de son état de santé. Son rapport est affiché à l'URI /ejbca/publicweb/healthcheck/ejbcahealth. Le script suivant interroge cette adresse et renvoie l'information au format NRPE :

#!/bin/bash

# Adresse du serveur
ServerAddress="localhost"

# URI de l'état de santé
Uri="/ejbca/publicweb/healthcheck/ejbcahealth"

# Requête
Request=$(curl -k -s https://${ServerAddress}${Uri})

# Traitement du résultat de la requête
if [ "$Request" == "ALLOK" ]; then
        # Tout va bien
        Status="GOOD"
        ExitCode=0
else
        # PKI en erreur
        Status="CRIT"
        ExitCode=2
fi

# Renvoi des informations
echo "$Status - Health status : $Request"
exit $ExitCode

On vérifie la présence de mise à jour en comparant le hash de la version actuelle de notre PKI avec le hash de la dernière version.

#!/bin/bash

# Adresse du serveur
ServerAddress="localhost"

# Uri du status
ServerUri="/ejbca/ejbca-rest-api/v1/certificate/status"

# Nom du container
Container="keyfactor/ejbca-ce"

# Récupération de la version actuelle
Actual=$(curl -k -s https://${ServerAddress}${ServerUri} | jq .revision | awk '{print $2}')

# Récupération du hash de la version actuelle
ActualHash=$(docker manifest inspect ${Container}:${Actual} | jq .config.digest)

# Récupération du hash de la dernière version
LatestHash=$(docker manifest inspect ${Container}:latest | jq .config.digest)

# Test et retour
if [ "$ActualHash" == "$LatestHash" ]; then
        # Les hash sont les mêmes, on est à jour
        echo "GOOD - up-to-date"
        exit 0
else
        # Une mise à jour est disponible
        echo "WARN - update available"
        exit 1
fi

On peut désormais créer des autorités de certifications : EJBCA - Création de certificats racine et intermédiaire