Serveur CA LXC Alpine Linux

Ce LXC permet d’héberger une petite autorité de certification locale (CA) pour le réseau interne.

Il sert à :

• signer les certificats TLS des services locaux ;
• distribuer le certificat public de la CA aux machines clientes ;
• centraliser la gestion des certificats ;
• obtenir un HTTPS propre sur le réseau local.

Prérequis

Pour une petite autorité de certification locale, un LXC très léger suffit :

• 1 vCPU
• 512 Mo à 1 Go de RAM
• 2 à 4 Go de disque

Installation

Mise à jour du système :

# apk update && apk upgrade

Installation des paquets nécessaires :

# apk add openssl openssh

Créer un dossier dédié à la CA :

# mkdir -p /etc/local-ca
# chmod 700 /etc/local-ca
# cd /etc/local-ca

Création de la clé privée de la CA :

# openssl genrsa -out local-ca.key 4096
# chmod 600 local-ca.key

Création du certificat public de la CA :

# openssl req -x509 -new -nodes -key local-ca.key -sha256 -days 3650 \
  -out local-ca.crt \
  -subj "/CN=CA-Locale-Homelab" \
  -addext "basicConstraints=critical,CA:TRUE" \
  -addext "keyUsage=critical,keyCertSign,cRLSign" \
  -addext "subjectKeyIdentifier=hash"
# chmod 644 local-ca.crt

• La clé privée local-ca.key doit rester sur ce serveur et ne jamais être copiée ailleurs.
• Le certificat public local-ca.crt peut en revanche être distribué aux machines clientes.

Pour faciliter l’installation du certificat public sur les machines du réseau local, on peut le rendre disponible via un petit serveur web très léger basé sur BusyBox HTTPD :

# apk add busybox-extras

Créer un dossier de publication :

# mkdir -p /srv/ca-public
# cp /etc/local-ca/local-ca.crt /srv/ca-public/
# chmod 755 /srv/ca-public
# chmod 644 /srv/ca-public/local-ca.crt

Test manuel du serveur web :

# busybox-extras httpd -f -p 8080 -h /srv/ca-public

Le certificat public devient alors accessible à l’adresse :

http://IP_DU_LXC:8080/local-ca.crt

Créer un petit script de démarrage :

# vi /usr/local/bin/start-ca-httpd.sh

Contenu :

#!/bin/sh
exec busybox-extras httpd -f -p 8080 -h /srv/ca-public

Rendre le script exécutable :

# chmod 755 /usr/local/bin/start-ca-httpd.sh

Créer un service OpenRC :

# vi /etc/init.d/ca-httpd

Contenu :

#!/sbin/openrc-run
description="BusyBox HTTPD pour la distribution du certificat public de la CA"
command="/usr/local/bin/start-ca-httpd.sh"
command_background="yes"
pidfile="/run/ca-httpd.pid"

Rendre le service exécutable :

# chmod 755 /etc/init.d/ca-httpd

Ajouter au démarrage et lancer :

# rc-update add ca-httpd default
# rc-service ca-httpd start

Installation du certificat public sur une machine distante

Debian / Ubuntu

Télécharger le certificat :

• Avec curl :

# curl http://IP_DU_LXC:8080/local-ca.crt -o /usr/local/share/ca-certificates/local-ca.crt

• Avec wget :

# wget -O /usr/local/share/ca-certificates/local-ca.crt http://IP_DU_LXC:8080/local-ca.crt

Mettre à jour le magasin de certificats :

# update-ca-certificates

Alpine Linux

Installer ca-certificates si nécessaire :

# apk update && apk upgrade
# apk add ca-certificates

Télécharger le certificat :

• Avec wget :

# wget -O /usr/local/share/ca-certificates/local-ca.crt http://IP_DU_LXC:8080/local-ca.crt

• Avec curl :

# curl http://IP_DU_LXC:8080/local-ca.crt -o /usr/local/share/ca-certificates/local-ca.crt

Mettre à jour le magasin de certificats :

# update-ca-certificates

Installation du certificat public dans un docker

Debian / Ubuntu

Exemple avec Docker Compose :

...
    volumes:
      - /usr/local/share/ca-certificates:/usr/local/share/ca-certificates:ro
    entrypoint: ["/bin/sh", "-c", "command -v update-ca-certificates >/dev/null 2>&1 || { apt update && apt install -y ca-certificates; }; update-ca-certificates && exec \"$$@\"", "--"]
...

Cette méthode monte le dossier des certificats de l’hôte dans le conteneur, installe ca-certificates si nécessaire, puis lance update-ca-certificates au démarrage du conteneur.

Attention : si l’image Docker utilise déjà un entrypoint, cette ligne le remplace. Dans ce cas, il faut appeler l’entrypoint original à la fin de la commande.

Exemple :

...
    volumes:
      - /usr/local/share/ca-certificates:/usr/local/share/ca-certificates:ro
    entrypoint: ["/bin/sh", "-c", "command -v update-ca-certificates >/dev/null 2>&1 || { apt update && apt install -y ca-certificates; }; update-ca-certificates && exec /chemin/entrypoint-original.sh \"$$@\"", "--"]
...

Après démarrage du conteneur, il est aussi possible de mettre à jour les certificats manuellement et éviter de toucher entrypoint :

# docker compose exec -u root nom_service sh -c "command -v update-ca-certificates >/dev/null 2>&1 || { apt update && apt install -y ca-certificates; }; update-ca-certificates"

Pour connaître l’entrypoint original de l’image :

# docker inspect nom_conteneur --format 'Image={{.Config.Image}} Entrypoint={{json .Config.Entrypoint}} Cmd={{json .Config.Cmd}}'

Applications Python / httpx / aiohttp / OpenAI

Certaines applications Python peuvent utiliser le magasin de certificats système via OpenSSL, mais il peut être utile de forcer explicitement le chemin du bundle de certificats.

Exemple avec Docker Compose :

...
    environment:
      - SSL_CERT_FILE=/etc/ssl/certs/ca-certificates.crt
      - SSL_CERT_DIR=/etc/ssl/certs
      - REQUESTS_CA_BUNDLE=/etc/ssl/certs/ca-certificates.crt
      - CURL_CA_BUNDLE=/etc/ssl/certs/ca-certificates.crt
...

Dans le cas d’une application Python utilisant httpx, aiohttp, requests ou le client openai, ces variables permettent de forcer l’utilisation du bundle système généré par update-ca-certificates.

Pour vérifier les chemins utilisés par Python :

# docker compose exec nom_service python -c "import ssl; print(ssl.get_default_verify_paths())"

Méthode de création de certificats simplifiée pour un homelab

Pour éviter l’échange manuel de CSR entre le serveur cible et le LXC CA, il est possible de générer directement la clé privée et le certificat du serveur sur le LXC CA, puis de les rendre disponibles temporairement via BusyBox HTTPD.

Cette méthode est plus simple, mais moins propre du point de vue de la sécurité, car la clé privée du serveur est créée sur le LXC CA et transite sur le réseau local.

Cette méthode est acceptable pour un homelab ou un réseau local de confiance, mais il reste préférable en théorie que la clé privée du serveur soit générée directement sur la machine cible.

1. Sur le LXC CA

Créer un dossier temporaire :

# mkdir -p /tmp/ca-tmp/mon_projet
# chmod 700 /tmp/ca-tmp/mon_projet
# cd /tmp/ca-tmp/mon_projet

Créer la clé privée du serveur :

# openssl genrsa -out server.key 4096
# chmod 600 server.key

Créer un fichier d’extensions :

# vi server.ext

---

Contenu pour un accès par IP :

authorityKeyIdentifier=keyid,issuer
basicConstraints=critical,CA:FALSE
keyUsage=critical,digitalSignature,keyEncipherment
extendedKeyUsage=serverAuth
subjectAltName=IP:IP_SERVEUR

---

Contenu pour un accès par nom DNS :

authorityKeyIdentifier=keyid,issuer
basicConstraints=critical,CA:FALSE
keyUsage=critical,digitalSignature,keyEncipherment
extendedKeyUsage=serverAuth
subjectAltName=DNS:NOM_DNS

---

Créer la demande de certificat :

# openssl req -new -key server.key -out server.csr \
  -subj "/CN=IP_SERVEUR_OU_NOM_DNS"

Signer le certificat :

# openssl x509 -req -in server.csr \
  -CA /etc/local-ca/local-ca.crt \
  -CAkey /etc/local-ca/local-ca.key \
  -CAcreateserial \
  -out server.crt \
  -days 825 -sha256 \
  -extfile server.ext
# chmod 644 server.crt

2. Publication temporaire

Lancer temporairement BusyBox HTTPD :

# busybox-extras httpd -f -p 8081 -h /tmp/ca-tmp/mon_projet

Les fichiers deviennent alors accessibles, par exemple :

http://IP_DU_LXC_CA:8081/server.key
http://IP_DU_LXC_CA:8081/server.crt

3. Sur le serveur cible

Créer un dossier de destination :

# mkdir -p /etc/mon_projet/ssl
# chmod 700 /etc/mon_projet/ssl

Télécharger les fichiers :

# wget -O /etc/mon_projet/ssl/server.key http://IP_DU_LXC_CA:8081/server.key
# wget -O /etc/mon_projet/ssl/server.crt http://IP_DU_LXC_CA:8081/server.crt

Corriger les permissions :

# chmod 600 /etc/mon_projet/ssl/server.key
# chmod 644 /etc/mon_projet/ssl/server.crt

4. Nettoyage

Dès que les fichiers ont été récupérés sur le serveur cible, arrêter BusyBox HTTPD sur le LXC CA et supprimer les fichiers temporaires :

Si BusyBox HTTPD a été lancé manuellement avec l’option -f, il faut d’abord l’arrêter avec Ctrl+C avant de supprimer le dossier temporaire.

# rm -r /tmp/ca-tmp