SSL-Zertifikat Docker Registry überprüfen: Anleitung & Tipps

Einführung

Die Sicherung Ihrer Docker-Umgebung ist von entscheidender Bedeutung, und die Überprüfung des SSL-Zertifikats, das von Ihrer Docker-Registry verwendet wird, ist ein wesentlicher Schritt zur Aufrechterhaltung dieser Sicherheit. Dieses Tutorial führt Sie durch den Prozess der Überprüfung von SSL-Zertifikaten für Docker-Registries und hilft Ihnen dabei, eine sichere Kommunikation zu gewährleisten und alle Probleme im Zusammenhang mit SSL-Zertifikaten zu beheben.

Am Ende dieses Labs werden Sie verstehen, wie Docker SSL-Zertifikate verwendet, in der Lage sein, die von Docker-Registries verwendeten Zertifikate zu inspizieren und zu überprüfen und wissen, wie Sie mit häufigen Zertifikatsproblemen umgehen.

Verständnis von Docker Registry SSL-Zertifikaten

Docker-Registries sind Repositories, in denen Docker-Images gespeichert und verteilt werden. Diese Registries verwenden SSL/TLS-Zertifikate, um die Kommunikation zwischen Ihrem Docker-Client und dem Registry-Server zu sichern. Lassen Sie uns verstehen, was diese Zertifikate sind und warum sie wichtig sind.

Was ist ein SSL/TLS-Zertifikat?

Ein SSL/TLS-Zertifikat ist ein digitales Dokument, das:

Eine sichere Verbindung zwischen einem Client und einem Server herstellt
Daten verschlüsselt, die zwischen ihnen übertragen werden
Die Identität des Servers verifiziert

Wenn Sie sich mit einer Docker-Registry verbinden, überprüft Ihr Docker-Client das SSL-Zertifikat der Registry, um sicherzustellen, dass die Verbindung sicher ist und dass Sie sich mit der legitimen Registry verbinden.

Untersuchen von Zertifikatinformationen mit OpenSSL

Beginnen wir damit, wie man Zertifikatinformationen mit OpenSSL, einem leistungsstarken Werkzeug für die Arbeit mit SSL-Zertifikaten, überprüft.

Zuerst erstellen wir ein Verzeichnis für unsere Lab-Arbeit:

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

Nun überprüfen wir das SSL-Zertifikat für Docker Hub, eine gängige Docker-Registry:

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

Dieser Befehl stellt eine Verbindung zu Docker Hub her und zeigt Informationen über sein SSL-Zertifikat an. Sie sollten eine Menge Informationen in der Ausgabe sehen, einschließlich:

Die Zertifikatskette (certificate chain)
Informationen zum Aussteller (Issuer)
Gültigkeitsdaten des Zertifikats
Der öffentliche Schlüssel (public key)

Lassen Sie uns nur die Zertifikatinformationen in einem besser lesbaren Format extrahieren:

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

Dieser Befehl zeigt die ersten 20 Zeilen der Zertifikatsdetails, die wichtige Informationen enthalten, wie z.B.:

Version
Seriennummer (Serial Number)
Signaturalgorithmus (Signature Algorithm)
Aussteller (die Zertifizierungsstelle - Certificate Authority)
Gültigkeitsdauer (Validity period)
Betreff (Subject - wem das Zertifikat gehört)

Das Verständnis dieser Informationen ist der erste Schritt zur Überprüfung der Echtheit eines Zertifikats.

Überprüfen von Registry SSL-Zertifikaten mit der Docker CLI

Nachdem wir die Grundlagen von SSL-Zertifikaten verstanden haben, wollen wir lernen, wie man Zertifikate speziell für Docker-Registries mit der Docker CLI überprüft.

Verwenden von `docker info` zur Überprüfung der Registry-Konfiguration

Die Docker CLI bietet Werkzeuge zur Untersuchung von Registry-Konfigurationen, einschließlich ihrer Zertifikatseinstellungen.

Überprüfen wir die aktuellen Registry-Konfigurationen, die Docker kennt:

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

Dieser Befehl gibt die Konfigurationsdetails für alle Registries aus, die der Docker-Daemon kennt, formatiert in einer lesbaren JSON-Struktur. Sie werden feststellen, dass Docker Hub (unter index.docker.io) standardmäßig konfiguriert ist.

Testen einer Verbindung zu einer Registry

Versuchen wir, uns mit Docker Hub zu verbinden, um sein Zertifikat zu überprüfen:

docker login

Wenn Sie dazu aufgefordert werden, können Sie Strg+C drücken, um die Anmeldung abzubrechen, da wir nur die Verbindung testen und uns nicht tatsächlich anmelden.

Der Docker-Client überprüft während des Anmeldevorgangs automatisch das SSL-Zertifikat der Registry. Wenn das Zertifikat gültig ist, sehen Sie die Anmeldeaufforderung. Andernfalls würde Docker eine Fehlermeldung anzeigen.

Erstellen einer Datei zur Überprüfung einer bestimmten Registry

Erstellen wir ein Skript, um das Zertifikat für eine bestimmte Registry gründlicher zu überprüfen:

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

Machen Sie das Skript jetzt ausführbar:

chmod +x check_registry_cert.sh

Führen wir es aus, um das Zertifikat von Docker Hub zu überprüfen:

./check_registry_cert.sh

Sie sollten eine Ausgabe sehen, die Folgendes zeigt:

Wann das Zertifikat ausgestellt wurde und wann es abläuft
Wer das Zertifikat ausgestellt hat
Wem das Zertifikat gehört
Informationen über die Zertifikatskette (certificate chain)

Überprüfen wir auch das Zertifikat für eine andere Registry, die Container-Registry von Microsoft:

./check_registry_cert.sh mcr.microsoft.com

Vergleichen Sie die Ausgaben, um zu sehen, wie sich Zertifikate zwischen Registries unterscheiden können.

Fehlerbehebung bei SSL-Zertifikatproblemen

Auch bei einem ordnungsgemäßen Überprüfungsprozess können bei der Arbeit mit Docker-Registries SSL-Zertifikatprobleme auftreten. Lassen Sie uns lernen, wie man die häufigsten Probleme identifiziert und behebt.

Häufige SSL-Zertifikatprobleme

Die häufigsten SSL-Zertifikatprobleme sind:

Selbstsignierte Zertifikate
Abgelaufene Zertifikate
Nicht übereinstimmende Zertifikat-Hostnamen
Nicht vertrauenswürdige Zertifizierungsstellen (Certificate Authorities)

Erstellen wir ein Verzeichnis, um diese Probleme zu simulieren und zu beheben:

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

Erstellen eines Test-selbstsignierten Zertifikats

Zuerst erstellen wir ein selbstsigniertes Zertifikat, um zu verstehen, wie man damit umgeht:

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

Dieser Befehl erstellt:

Einen privaten Schlüssel (registry.key)
Ein selbstsigniertes Zertifikat (registry.crt), das 365 Tage gültig ist

Untersuchen wir unser selbstsigniertes Zertifikat:

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

Beachten Sie, dass bei einem selbstsignierten Zertifikat der Aussteller (Issuer) und der Betreff (Subject) identisch sind, da sich das Zertifikat selbst signiert hat.

Konfigurieren von Docker, um einem selbstsignierten Zertifikat zu vertrauen

Damit Docker einem selbstsignierten Zertifikat vertraut, würden Sie es typischerweise dem Docker-Zertifikatsverzeichnis hinzufügen. Erstellen wir die notwendige Verzeichnisstruktur:

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

Nach dem Hinzufügen eines Zertifikats würden Sie normalerweise Docker neu starten:

## In diesem Lab werden wir Docker nicht tatsächlich neu starten
echo "In einer realen Umgebung würden Sie Folgendes ausführen: sudo systemctl restart docker"

Umgang mit abgelaufenen Zertifikaten

Simulieren wir die Überprüfung eines abgelaufenen Zertifikats, indem wir eines mit einem abgelaufenen Ablaufdatum erstellen:

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

Untersuchen wir nun das abgelaufene Zertifikat:

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

Sie werden sehen, dass das Datum "Not After" in der Vergangenheit liegt, was bedeutet, dass das Zertifikat abgelaufen ist.

Konfigurieren unsicherer Registries

In einigen Fällen müssen Sie möglicherweise Registries mit Zertifikatsproblemen verwenden. Docker ermöglicht es Ihnen, bestimmte Registries als "unsicher" zu markieren:

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

echo "In einer realen Umgebung würden Sie diese Datei unter /etc/docker/daemon.json ablegen"
cat daemon.json

Diese Konfiguration weist Docker an, die Zertifikatsüberprüfung für diese Registries zu überspringen, was für Testumgebungen nützlich sein kann, aber in der Produktion vermieden werden sollte.

Skript zur Überprüfung des Zertifikatablaufs

Erstellen wir ein nützliches Skript, um zu überprüfen, ob ein Zertifikat bald abläuft:

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

Testen wir unser Skript mit beiden Zertifikaten:

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

Sie werden sehen, dass das Skript das gültige Zertifikat und das abgelaufene Zertifikat korrekt identifiziert.

Best Practices für Docker Registry SSL-Zertifikate

Nachdem wir verstanden haben, wie man SSL-Zertifikate überprüft und Fehler behebt, wollen wir uns mit Best Practices für die Verwaltung von Zertifikaten mit Docker-Registries befassen.

Automatisierung der Zertifikatsüberprüfung

Es ist unerlässlich, Ihre Zertifikate regelmäßig zu überprüfen, um unerwartete Ausfälle zu vermeiden. Erstellen wir ein Skript, das regelmäßig ausgeführt werden kann:

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

Führen wir das Skript aus, um zu sehen, wie es funktioniert:

./monitor_registry_certs.sh

Dieses Skript überprüft mehrere Registries und warnt Sie, wenn sich Zertifikate dem Ablauf nähern, was entscheidend ist, um unerwartete Ausfallzeiten zu verhindern.

Best Practices für die Zertifikatsverwaltung

Erstellen wir ein Dokument, das die Best Practices für die Verwaltung von Docker-Registry-Zertifikaten umreißt:

cat > certificate_best_practices.md << 'EOF'
## Docker Registry Certificate Management Best Practices

### Certificate Procurement
- Use certificates from trusted Certificate Authorities for production environments
- Use appropriate certificate types (DV, OV, or EV based on needs)
- Ensure certificates match the exact domain names used to access registries
- Consider wildcard certificates for multiple subdomains
- Use appropriate key lengths (minimum 2048 bits for RSA)

### Certificate Deployment
- Store certificates securely
- Use proper file permissions (readable only by the Docker daemon)
- Back up certificates and private keys securely
- Implement proper certificate rotation procedures
- Keep certificate paths consistent across all nodes in a cluster

### Monitoring and Maintenance
- Set up alerts for certificates nearing expiration (at least 30 days in advance)
- Maintain an inventory of all certificates in use
- Document renewal procedures
- Test certificate renewals in a staging environment before production
- Automate certificate renewal where possible (using tools like certbot)

### Security Considerations
- Never use insecure registries in production environments
- Avoid using self-signed certificates in production
- Implement proper certificate revocation procedures
- Regularly audit certificate usage and permissions
- Keep the CA bundle updated on all systems
EOF

cat certificate_best_practices.md

Erstellen einer Konfigurationsvorlage für sichere Registries

Schließlich erstellen wir eine Vorlage für eine sichere Docker-Registry-Konfiguration:

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

Diese Konfiguration bietet eine Vorlage für den Betrieb einer sicheren Docker-Registry mit korrekter SSL-Zertifikatskonfiguration.

Zusammenfassung der Schritte zur SSL-Zertifikatsverwaltung

Erstellen wir eine Kurzübersicht für die SSL-Zertifikatsverwaltung mit Docker:

cat > ssl_management_summary.txt << 'EOF'
## Docker Registry SSL Certificate Management Summary

1. VERIFY a registry's certificate:
   openssl s_client -connect registry.example.com:443 -showcerts </dev/null

2. ADD a custom certificate for a registry:
   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. CONFIGURE an insecure registry (development only):
   Add to /etc/docker/daemon.json:
   { "insecure-registries": ["registry.example.com:5000"] }
   sudo systemctl restart docker

4. CHECK expiration dates regularly:
   openssl x509 -in certificate.crt -noout -dates

5. AUTOMATE certificate monitoring:
   Create and schedule scripts to check certificates regularly
EOF

cat ssl_management_summary.txt

Diese Zusammenfassung dient als Kurzübersicht für die häufigsten Operationen im Zusammenhang mit Docker-Registry-SSL-Zertifikaten.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie man SSL-Zertifikate für Docker-Registries verifiziert und verwaltet. Sie verfügen nun über das Wissen und die Werkzeuge, um:

Zu verstehen, was SSL-Zertifikate sind und warum sie für die Sicherheit von Docker-Registries unerlässlich sind
SSL-Zertifikate mit OpenSSL und Docker CLI-Befehlen zu verifizieren
Häufige Zertifikatsprobleme wie abgelaufene Zertifikate und selbstsignierte Zertifikate zu beheben
Best Practices für die Zertifikatsverwaltung zu implementieren
Docker so zu konfigurieren, dass es mit verschiedenen Zertifikatsszenarien arbeitet
Die Zertifikatsüberwachung zu automatisieren, um unerwartete Ausfälle zu verhindern

Diese Fähigkeiten sind entscheidend für die Aufrechterhaltung sicherer Docker-Umgebungen, insbesondere in Produktionsumgebungen, in denen Sicherheit von größter Bedeutung ist. Durch die regelmäßige Überprüfung und ordnungsgemäße Verwaltung Ihrer Docker-Registry-SSL-Zertifikate können Sie Sicherheitslücken verhindern und einen reibungslosen Betrieb Ihrer containerisierten Anwendungen gewährleisten.

So überprüfen Sie das SSL-Zertifikat einer Docker Registry