Comment vérifier le certificat SSL utilisé par un registre Docker

DockerBeginner
Pratiquer maintenant

Introduction

Sécuriser votre environnement Docker est crucial, et vérifier le certificat SSL utilisé par votre registre Docker est une étape essentielle pour maintenir cette sécurité. Ce tutoriel vous guidera à travers le processus de vérification des certificats SSL pour les registres Docker, vous aidant à assurer une communication sécurisée et à dépanner tout problème lié aux certificats SSL.

À la fin de ce lab, vous comprendrez comment Docker utilise les certificats SSL, serez capable d'inspecter et de vérifier les certificats utilisés par les registres Docker, et saurez comment gérer les problèmes de certificats courants.

Comprendre les certificats SSL des registres Docker

Les registres Docker sont des référentiels où les images Docker sont stockées et distribuées. Ces registres utilisent des certificats SSL/TLS pour sécuriser la communication entre votre client Docker et le serveur du registre. Comprenons ce que sont ces certificats et pourquoi ils sont importants.

Qu'est-ce qu'un certificat SSL/TLS ?

Un certificat SSL/TLS est un document numérique qui :

  • Établit une connexion sécurisée entre un client et un serveur
  • Chiffre les données transmises entre eux
  • Vérifie l'identité du serveur

Lorsque vous vous connectez à un registre Docker, votre client Docker vérifie le certificat SSL du registre pour s'assurer que la connexion est sécurisée et que vous vous connectez au registre légitime.

Examiner les informations du certificat avec OpenSSL

Commençons par explorer comment vérifier les informations du certificat à l'aide d'OpenSSL, un outil puissant pour travailler avec les certificats SSL.

Tout d'abord, créons un répertoire pour notre travail de lab :

mkdir -p ~/project/ssl-lab
cd ~/project/ssl-lab

Maintenant, vérifions le certificat SSL pour Docker Hub, qui est un registre Docker courant :

openssl s_client -connect hub.docker.com:443 -showcerts < /dev/null

Cette commande se connecte à Docker Hub et affiche des informations sur son certificat SSL. Vous devriez voir beaucoup d'informations dans la sortie, notamment :

  • La chaîne de certificats
  • Les informations sur l'émetteur
  • Les dates de validité du certificat
  • La clé publique

Extrayons uniquement les informations du certificat dans un format plus lisible :

echo | openssl s_client -connect hub.docker.com:443 2> /dev/null | openssl x509 -text -noout | head -20

Cette commande affiche les 20 premières lignes des détails du certificat, qui incluent des informations importantes telles que :

  • Version
  • Numéro de série
  • Algorithme de signature
  • Émetteur (l'autorité de certification)
  • Période de validité
  • Sujet (à qui appartient le certificat)

Comprendre ces informations est la première étape pour vérifier l'authenticité d'un certificat.

Vérification des certificats SSL de registre avec la CLI Docker

Maintenant que nous comprenons les bases des certificats SSL, apprenons à vérifier les certificats spécifiquement pour les registres Docker en utilisant la CLI Docker.

Utilisation de docker info pour vérifier la configuration du registre

La CLI Docker fournit des outils pour examiner les configurations de registre, y compris leurs paramètres de certificat.

Vérifions les configurations de registre actuelles que Docker connaît :

docker info --format '{{json .RegistryConfig.IndexConfigs}}' | python3 -m json.tool

Cette commande affiche les détails de configuration pour tous les registres que le démon Docker connaît, formatés dans une structure JSON lisible. Vous remarquerez que Docker Hub (à index.docker.io) est configuré par défaut.

Tester une connexion à un registre

Essayons de nous connecter à Docker Hub pour vérifier son certificat :

docker login

Lorsque vous y êtes invité, vous pouvez appuyer sur Ctrl+C pour annuler la connexion puisque nous testons simplement la connexion, sans réellement nous connecter.

Le client Docker vérifie automatiquement le certificat SSL du registre pendant le processus de connexion. Si le certificat est valide, vous verrez l'invite de connexion. Sinon, Docker affichera un message d'erreur.

Création d'un fichier pour vérifier un registre spécifique

Créons un script pour vérifier le certificat d'un registre spécifique plus en détail :

cat > check_registry_cert.sh << 'EOF'
#!/bin/bash

REGISTRY=${1:-"hub.docker.com"}
PORT=${2:-"443"}

echo "Checking certificate for $REGISTRY:$PORT..."
echo | openssl s_client -connect $REGISTRY:$PORT 2>/dev/null | openssl x509 -noout -dates -issuer -subject

echo -e "\nVerifying certificate chain..."
openssl s_client -connect $REGISTRY:$PORT -showcerts </dev/null 2>/dev/null | grep -A 1 "Certificate chain"
EOF

Maintenant, rendez le script exécutable :

chmod +x check_registry_cert.sh

Exécutons-le pour vérifier le certificat de Docker Hub :

./check_registry_cert.sh

Vous devriez voir une sortie indiquant :

  • Quand le certificat a été émis et quand il expire
  • Qui a émis le certificat
  • À qui appartient le certificat
  • Des informations sur la chaîne de certificats

Vérifions également le certificat d'un autre registre, le registre de conteneurs de Microsoft :

./check_registry_cert.sh mcr.microsoft.com

Comparez les sorties pour voir comment les certificats peuvent différer entre les registres.

Dépannage des problèmes de certificat SSL

Même avec un processus de vérification approprié, vous pouvez rencontrer des problèmes de certificat SSL lorsque vous travaillez avec des registres Docker. Apprenons à identifier et à résoudre les problèmes les plus courants.

Problèmes courants de certificat SSL

Les problèmes de certificat SSL les plus fréquents incluent :

  1. Certificats auto-signés
  2. Certificats expirés
  3. Incompatibilités de nom d'hôte de certificat
  4. Autorités de certification non fiables

Créons un répertoire pour simuler et dépanner ces problèmes :

mkdir -p ~/project/ssl-lab/troubleshooting
cd ~/project/ssl-lab/troubleshooting

Création d'un certificat auto-signé de test

Tout d'abord, créons un certificat auto-signé pour comprendre comment les gérer :

openssl req -newkey rsa:2048 -nodes -keyout registry.key -x509 -days 365 -out registry.crt -subj "/CN=registry.example.com"

Cette commande crée :

  • Une clé privée (registry.key)
  • Un certificat auto-signé (registry.crt) valable pendant 365 jours

Examinons notre certificat auto-signé :

openssl x509 -in registry.crt -text -noout | grep -E "Issuer|Subject|Not"

Notez que dans un certificat auto-signé, l'émetteur et le sujet sont les mêmes, car le certificat s'est signé lui-même.

Configuration de Docker pour faire confiance à un certificat auto-signé

Pour que Docker fasse confiance à un certificat auto-signé, vous devez généralement l'ajouter au répertoire des certificats Docker. Créons la structure de répertoire nécessaire :

sudo mkdir -p /etc/docker/certs.d/registry.example.com:5000
sudo cp registry.crt /etc/docker/certs.d/registry.example.com:5000/ca.crt

Après avoir ajouté un certificat, vous redémarreriez normalement Docker :

## Nous ne redémarrerons pas réellement Docker dans ce lab
echo "Dans un environnement réel, vous exécuteriez : sudo systemctl restart docker"

Gestion des certificats expirés

Simulons la vérification d'un certificat expiré en en créant un avec une date d'expiration passée :

openssl req -newkey rsa:2048 -nodes -keyout expired.key -x509 -days -30 -out expired.crt -subj "/CN=expired.example.com"

Examinons maintenant le certificat expiré :

openssl x509 -in expired.crt -text -noout | grep -E "Issuer|Subject|Not"

Vous verrez que la date "Not After" est dans le passé, ce qui signifie que le certificat est expiré.

Configuration des registres non sécurisés

Dans certains cas, vous devrez peut-être utiliser des registres avec des problèmes de certificat. Docker vous permet de marquer des registres spécifiques comme "non sécurisés" :

cat > daemon.json << 'EOF'
{
  "insecure-registries": [
    "registry.example.com:5000",
    "expired.example.com:5000"
  ]
}
EOF

echo "Dans un environnement réel, vous placeriez ce fichier à /etc/docker/daemon.json"
cat daemon.json

Cette configuration indique à Docker d'ignorer la vérification du certificat pour ces registres, ce qui peut être utile pour les environnements de test, mais doit être évité en production.

Script pour vérifier l'expiration du certificat

Créons un script utile pour vérifier si un certificat est sur le point d'expirer :

cat > check_expiration.sh << 'EOF'
#!/bin/bash

CERT_FILE=$1
DAYS_WARNING=${2:-30}

if [ ! -f "$CERT_FILE" ]; then
    echo "Certificate file not found: $CERT_FILE"
    exit 1
fi

## Get expiration date in seconds since epoch
EXPIRY=$(openssl x509 -in "$CERT_FILE" -noout -enddate | cut -d= -f2)
EXPIRY_SECONDS=$(date -d "$EXPIRY" +%s)
NOW_SECONDS=$(date +%s)
SECONDS_LEFT=$((EXPIRY_SECONDS - NOW_SECONDS))
DAYS_LEFT=$((SECONDS_LEFT / 86400))

echo "Certificate: $CERT_FILE"
echo "Expires on: $EXPIRY"
echo "Days remaining: $DAYS_LEFT"

if [ $DAYS_LEFT -lt 0 ]; then
    echo "CRITICAL: Certificate has EXPIRED!"
    exit 2
elif [ $DAYS_LEFT -lt $DAYS_WARNING ]; then
    echo "WARNING: Certificate will expire in less than $DAYS_WARNING days!"
    exit 1
else
    echo "OK: Certificate is valid for more than $DAYS_WARNING days."
    exit 0
fi
EOF

chmod +x check_expiration.sh

Testons notre script avec les deux certificats :

./check_expiration.sh registry.crt
./check_expiration.sh expired.crt

Vous verrez que le script identifie correctement le certificat valide et celui expiré.

Bonnes pratiques pour les certificats SSL de registre Docker

Maintenant que nous comprenons comment vérifier et dépanner les certificats SSL, explorons les bonnes pratiques pour la gestion des certificats avec les registres Docker.

Automatisation de la vérification des certificats

Il est essentiel de vérifier régulièrement vos certificats pour éviter les pannes inattendues. Créons un script qui peut être planifié pour s'exécuter périodiquement :

cd ~/project/ssl-lab
cat > monitor_registry_certs.sh << 'EOF'
#!/bin/bash

## List of registries to check
REGISTRIES=(
  "hub.docker.com"
  "mcr.microsoft.com"
  "registry.k8s.io"
  "quay.io"
)

echo "========================================"
echo "Docker Registry Certificate Monitor"
echo "========================================"
echo "Date: $(date)"
echo ""

for registry in "${REGISTRIES[@]}"; do
  echo "Checking $registry..."
  CERT_INFO=$(echo | openssl s_client -connect $registry:443 2>/dev/null | openssl x509 -noout -dates -issuer -subject 2>/dev/null)
  
  if [ -z "$CERT_INFO" ]; then
    echo "ERROR: Could not retrieve certificate for $registry"
  else
    echo "$CERT_INFO"
    
    ## Extract expiry date
    EXPIRY=$(echo "$CERT_INFO" | grep "notAfter" | cut -d= -f2)
    EXPIRY_SECONDS=$(date -d "$EXPIRY" +%s)
    NOW_SECONDS=$(date +%s)
    DAYS_LEFT=$(( (EXPIRY_SECONDS - NOW_SECONDS) / 86400 ))
    
    echo "Days until expiry: $DAYS_LEFT"
    
    if [ $DAYS_LEFT -lt 30 ]; then
      echo "WARNING: Certificate will expire in less than 30 days!"
    fi
  fi
  echo "----------------------------------------"
done
EOF

chmod +x monitor_registry_certs.sh

Exécutons le script pour voir comment il fonctionne :

./monitor_registry_certs.sh

Ce script vérifie plusieurs registres et vous avertit si des certificats approchent de leur expiration, ce qui est crucial pour éviter les temps d'arrêt imprévus.

Bonnes pratiques de gestion des certificats

Créons un document décrivant les bonnes pratiques pour la gestion des certificats de registre Docker :

cat > certificate_best_practices.md << 'EOF'
## Bonnes pratiques de gestion des certificats de registre Docker

### Acquisition de certificats
- Utilisez des certificats provenant d'autorités de certification (CA) de confiance pour les environnements de production
- Utilisez des types de certificats appropriés (DV, OV ou EV en fonction des besoins)
- Assurez-vous que les certificats correspondent aux noms de domaine exacts utilisés pour accéder aux registres
- Envisagez des certificats génériques (wildcard) pour plusieurs sous-domaines
- Utilisez des longueurs de clé appropriées (minimum 2048 bits pour RSA)

### Déploiement des certificats
- Stockez les certificats en toute sécurité
- Utilisez des permissions de fichier appropriées (lisibles uniquement par le démon Docker)
- Sauvegardez les certificats et les clés privées en toute sécurité
- Mettez en œuvre des procédures de rotation des certificats appropriées
- Conservez des chemins de certificat cohérents sur tous les nœuds d'un cluster

### Surveillance et maintenance
- Configurez des alertes pour les certificats approchant de leur expiration (au moins 30 jours à l'avance)
- Tenez un inventaire de tous les certificats utilisés
- Documentez les procédures de renouvellement
- Testez les renouvellements de certificats dans un environnement de pré-production avant la production
- Automatisez le renouvellement des certificats dans la mesure du possible (en utilisant des outils comme certbot)

### Considérations de sécurité
- N'utilisez jamais de registres non sécurisés dans les environnements de production
- Évitez d'utiliser des certificats auto-signés en production
- Mettez en œuvre des procédures de révocation de certificats appropriées
- Auditez régulièrement l'utilisation et les permissions des certificats
- Maintenez le bundle CA à jour sur tous les systèmes
EOF

cat certificate_best_practices.md

Création d'un modèle de configuration pour les registres sécurisés

Enfin, créons un modèle pour une configuration de registre Docker sécurisée :

cat > secure_registry_config.yml << 'EOF'
version: '3'

services:
  registry:
    image: registry:2
    ports:
      - 5000:5000
    environment:
      REGISTRY_HTTP_TLS_CERTIFICATE: /certs/domain.crt
      REGISTRY_HTTP_TLS_KEY: /certs/domain.key
      ## Additional security settings
      REGISTRY_STORAGE_DELETE_ENABLED: "true"
      REGISTRY_HTTP_HEADERS_X_CONTENT_TYPE_OPTIONS: nosniff
      REGISTRY_HTTP_HEADERS_X_FRAME_OPTIONS: DENY
    volumes:
      - ./certs:/certs
      - ./data:/var/lib/registry
    restart: always
    
  ## Optional: Add a UI for your registry
  registry-ui:
    image: joxit/docker-registry-ui:latest
    ports:
      - 8080:80
    environment:
      - REGISTRY_URL=https://registry:5000
      - REGISTRY_TITLE=Secure Docker Registry
      - SINGLE_REGISTRY=true
    depends_on:
      - registry
EOF

cat secure_registry_config.yml

Cette configuration fournit un modèle pour l'exécution d'un registre Docker sécurisé avec une configuration de certificat SSL appropriée.

Résumé des étapes de gestion des certificats SSL

Créons une référence rapide pour la gestion des certificats SSL avec Docker :

cat > ssl_management_summary.txt << 'EOF'
## Résumé de la gestion des certificats SSL de registre Docker

1. VÉRIFIER le certificat d'un registre :
   openssl s_client -connect registry.example.com:443 -showcerts </dev/null

2. AJOUTER un certificat personnalisé pour un registre :
   sudo mkdir -p /etc/docker/certs.d/registry.example.com:5000
   sudo cp registry.crt /etc/docker/certs.d/registry.example.com:5000/ca.crt
   sudo systemctl restart docker

3. CONFIGURER un registre non sécurisé (développement uniquement) :
   Ajouter à /etc/docker/daemon.json :
   { "insecure-registries": ["registry.example.com:5000"] }
   sudo systemctl restart docker

4. VÉRIFIER régulièrement les dates d'expiration :
   openssl x509 -in certificate.crt -noout -dates

5. AUTOMATISER la surveillance des certificats :
   Créer et planifier des scripts pour vérifier régulièrement les certificats
EOF

cat ssl_management_summary.txt

Ce résumé sert de référence rapide pour les opérations les plus courantes liées aux certificats SSL de registre Docker.

Résumé

Dans ce lab, vous avez appris à vérifier et à gérer les certificats SSL pour les registres Docker. Vous avez maintenant les connaissances et les outils pour :

  • Comprendre ce que sont les certificats SSL et pourquoi ils sont essentiels pour la sécurité des registres Docker
  • Vérifier les certificats SSL à l'aide des commandes OpenSSL et Docker CLI
  • Dépanner les problèmes courants de certificat tels que les certificats expirés et les certificats auto-signés
  • Mettre en œuvre les meilleures pratiques pour la gestion des certificats
  • Configurer Docker pour qu'il fonctionne avec divers scénarios de certificats
  • Automatiser la surveillance des certificats pour éviter les pannes inattendues

Ces compétences sont cruciales pour maintenir des environnements Docker sécurisés, en particulier dans les environnements de production où la sécurité est primordiale. En vérifiant régulièrement et en gérant correctement vos certificats SSL de registre Docker, vous pouvez prévenir les vulnérabilités de sécurité et assurer le bon fonctionnement de vos applications conteneurisées.