Mise en place d'un laboratoire local TLS avec exemples pratiques : guide d'implémentation

Introduction

Un laboratoire TLS local est idéal pour apprendre la génération de certificats, la configuration serveur et le débogage sans mettre en péril un environnement de production. Ce guide de TLS certificates setup vous propose un parcours simple et vérifiable, centré sur des exemples pratiques et reproductibles. Vous allez :

• Créer une autorité de certification (AC) locale
• Émettre un certificat serveur pour app.local (127.0.0.1)
• Configurer un reverse proxy Nginx avec TLS et des valeurs par défaut sûres
• Valider avec curl et OpenSSL
• En option, activer le mutual TLS (certificats clients)
• Étendre l'usage aux ressources Kubernetes Ingress

L'objectif est un TLS certificates local lab minimaliste et testable que vous pouvez inspecter entièrement sur votre machine. Restez local, restez simple, et n'ajoutez de la complexité qu'après avoir des vérifications fiables. Vos exercices de TLS certificates testing et vos TLS certificates examples soutiendront votre TLS certificates development au quotidien.

Vue d'ensemble du flux de travail

Un workflow clair et par étapes limite les itérations inutiles et accélère l'apprentissage.

1. Nommez vos endpoints locaux

• Choisissez des noms qui ne se résolvent pas publiquement, par exemple : app.local, api.local
• Mappez-les vers 127.0.0.1 dans votre fichier hosts :
• Linux/macOS : /etc/hosts
• Windows : C:\\Windows\\System32\\drivers\\etc\\hosts

Exemple d'entrées :

127.0.0.1 app.local
127.0.0.1 api.local

Deux options courantes. Choisissez celle qui vous convient.

1. Créez une AC locale et émettez un certificat serveur

Option A : OpenSSL (fonctionne partout)

# 1) Créer une AC racine (privée !)
mkdir -p certs
openssl genrsa -out certs/rootCA.key 4096
openssl req -x509 -new -nodes -key certs/rootCA.key -sha256 -days 3650 \
  -out certs/rootCA.crt -subj "/CN=lab-root-ca"

# 2) Créer une clé serveur et une CSR pour app.local
openssl genrsa -out certs/app.local.key 2048
openssl req -new -key certs/app.local.key -out certs/app.local.csr \
  -subj "/CN=app.local"

# 3) Définir les SAN et usages pour le certificat serveur
cat > certs/app.local.ext <<'EOF'
subjectAltName = @alt_names
basicConstraints = CA:FALSE
keyUsage = digitalSignature, keyEncipherment
extendedKeyUsage = serverAuth
[alt_names]
DNS.1 = app.local
DNS.2 = localhost
IP.1 = 127.0.0.1
EOF

# 4) Signer la CSR serveur avec votre AC
openssl x509 -req -in certs/app.local.csr -CA certs/rootCA.crt -CAkey certs/rootCA.key \
  -CAcreateserial -out certs/app.local.crt -days 825 -sha256 -extfile certs/app.local.ext

Option B : mkcert (AC locale pratique)

# Initialiser le magasin de confiance local pour mkcert
mkcert -install

# Émettre un cert couvrant vos noms et loopback
mkcert -cert-file certs/app.local.crt -key-file certs/app.local.key \
  app.local 127.0.0.1 localhost

# mkcert crée aussi sa racine (emplacement variable selon l'OS)

Créez un serveur Nginx minimal qui termine TLS et renvoie une réponse simple. Adaptez les chemins absolus selon votre environnement.

1. Configurez Nginx avec TLS

nginx.conf (ou un site inclus) :

server {
    listen 443 ssl http2;
    server_name app.local;

    ssl_certificate     /absolute/path/certs/app.local.crt;
    ssl_certificate_key /absolute/path/certs/app.local.key;

    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers 'ECDHE-ECDSA-AES256-GCM-SHA384: ECDHE-RSA-AES256-GCM-SHA384: ECDHE-ECDSA-CHACHA20-POLY1305: ECDHE-RSA-CHACHA20-POLY1305: ECDHE-ECDSA-AES128-GCM-SHA256: ECDHE-RSA-AES128-GCM-SHA256';
    ssl_prefer_server_ciphers on;
    ssl_session_cache shared: SSL:10m;
    ssl_session_timeout 1h;

    # HSTS pour le lab : sans risque si app.local n'est qu'en local
    add_header Strict-Transport-Security "max-age=31536000" always;

    location / {
        return 200 'hello tls lab\n';
        add_header Content-Type text/plain;
    }
}

server {
    listen 80;
    server_name app.local;
    return 301 https://$host$request_uri;
}

Rechargez Nginx après test de la configuration :

nginx -t && nginx -s reload
# ou avec systemd
# sudo systemctl reload nginx

Vous pouvez faire confiance à votre AC au niveau du système (optionnel) ou indiquer explicitement la chaîne de confiance aux outils.

1. Validez avec curl et OpenSSL

Confiance système (optionnel, nécessite des privilèges admin) :

• macOS :

sudo security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain certs/rootCA.crt

• Debian/Ubuntu :

sudo cp certs/rootCA.crt /usr/local/share/ca-certificates/lab-root-ca.crt
sudo update-ca-certificates

• Windows (cmd ou PowerShell en Administrateur) :

certutil -addstore -f "Root" certs\rootCA.crt

Validation directe sans confiance système :

# Utiliser hosts et la CA explicitement
curl -vkI https://app.local --cacert certs/rootCA.crt

# Inspecter le certificat servi
openssl s_client -connect app.local:443 -servername app.local -showcerts < /dev/null \
  | openssl x509 -noout -subject -issuer -dates

1. Optionnel : activer le mutual TLS (certificats clients)

# Créer une clé client et une CSR
openssl genrsa -out certs/client.key 2048
openssl req -new -key certs/client.key -out certs/client.csr -subj "/CN=lab-client"

# Extensions minimales du certificat client
cat > certs/client.ext <<'EOF'
basicConstraints = CA:FALSE
keyUsage = digitalSignature, keyEncipherment
extendedKeyUsage = clientAuth
EOF

# Signer le certificat client
openssl x509 -req -in certs/client.csr -CA certs/rootCA.crt -CAkey certs/rootCA.key \
  -CAcreateserial -out certs/client.crt -days 365 -sha256 -extfile certs/client.ext

Extrait Nginx mTLS :

ssl_client_certificate /absolute/path/certs/rootCA.crt;
ssl_verify_client optional;  # ou 'on' pour exiger tous les appels

location /secure/ {
    if ($ssl_client_verify != SUCCESS) { return 403; }
    return 200 'hello mtls client\n';
    add_header Content-Type text/plain;
}

Tester le mTLS :

# Sans cert client : attendez 403 sur /secure/
curl -vk https://app.local/secure/ --cacert certs/rootCA.crt

# Avec cert client : attendez 200
curl -vk https://app.local/secure/ --cacert certs/rootCA.crt \
  --cert certs/client.crt --key certs/client.key

Si vous avez déjà un cluster local (kind, minikube, etc.) avec un Ingress controller, réutilisez le même certificat et la même clé.

1. Étendre à Kubernetes Ingress (optionnel)

Créer un secret TLS :

kubectl create namespace demo
kubectl -n demo create secret tls app-local-tls \
  --cert=certs/app.local.crt --key=certs/app.local.key

Manifeste Ingress (exemple nginx Ingress) :

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: app-local
  namespace: demo
  annotations:
    nginx.ingress.kubernetes.io/ssl-redirect: "true"
spec:
  tls:
  - hosts:
    - app.local
    secretName: app-local-tls
  rules:
  - host: app.local
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: app-svc
            port:
              number: 80

Pointez app.local vers l'endpoint Ingress (NodePort, LoadBalancer ou port-forward). Exemple avec port-forward du controller vers localhost :

# Adaptez les noms à votre service controller
kubectl -n ingress-nginx port-forward svc/ingress-nginx-controller 8443:443
# Puis :
curl -vkI https://app.local:8443 --resolve app.local:8443:127.0.0.1 --cacert certs/rootCA.crt

1. Faire tourner les certificats en toute sécurité

• Émettre un nouveau certificat serveur avec les mêmes SAN
• Mettre à jour les chemins de fichiers de manière atomique (ou écraser les fichiers)
• Valider la configuration Nginx et recharger

openssl x509 -in certs/app.local.crt -noout -enddate
nginx -t && nginx -s reload

1. Dépannage : gains rapides

• Décalage de nom d'hôte : vérifiez les SAN avec openssl x509 -in certs/app.local.crt -noout -text | grep -A1 \"Subject Alternative Name\"
• Chaîne incorrecte : confirmez l'émetteur avec -issuer et assurez-vous que le serveur envoie le bon certificat
• Protocole/chiffrement : curl -v --tls-max 1.2 https://app.local pour vérifier la compatibilité des versions
• Logs Nginx : inspectez l'erreur log pour les erreurs de poignée de main (handshake) ou de certificat

Plan pilote local

Objectif : un seul nom d'hôte (app.local) en TLS sur localhost, avec des vérifications mesurables.

Portée

• Serveur unique : Nginx sur 127.0.0.1
• Un nom d'hôte : app.local
• Une AC, un certificat serveur

Étapes

1. Ajouter l'entrée hosts app.local -> 127.0.0.1
2. Créer une AC locale et un certificat serveur (commandes OpenSSL ci-dessus)
3. Configurer Nginx avec TLS
4. Valider avec curl et OpenSSL

Critères de succès (mesurables)

• curl -skI https://app.local --cacert certs/rootCA.crt retourne HTTP/1.1 ou HTTP/2 200 OK pour le vhost TLS
• openssl s_client -connect app.local:443 -servername app.local montre une chaîne avec issuer = lab-root-ca et une date d'expiration future
• nginx -t réussit et nginx -s reload s'exécute sans erreurs

Timebox

• 45 à 60 minutes de bout en bout, validation incluse

Extension optionnelle

• Ajouter le mTLS pour /secure/ et vérifier 403 sans certificat client puis 200 avec

Prolongement après réussite

• Ajouter api.local comme second hôte en utilisant la même AC et répéter les vérifications

Conclusion

Vous avez mis en place un petit laboratoire TLS sûr et réutilisable pour le test, le dépannage et l'expérimentation. Vous avez créé une AC locale, émis des certificats serveur et client, configuré Nginx avec des valeurs raisonnables, et validé le comportement avec curl et OpenSSL. Poursuivez par des améliorations incrémentales : script d'émission et de rotation, ajout de nouveaux hôtes, et réutilisation dans un Ingress Kubernetes. Conservez des vérifications locales claires afin de valider chaque changement avant de passer à l'étape suivante.