macOS Tahoe 26.3 hat SSH Beschädigt: Änderungen der Groß-/Kleinschreibung, DSA-Schlüssel-Entfernung & Vollständiger Reparaturleitfaden

macOSTahoe ·
macOS Tahoe 26.3 hat SSH Beschädigt: Änderungen der Groß-/Kleinschreibung, DSA-Schlüssel-Entfernung & Vollständiger Reparaturleitfaden

macOS Tahoe 26.3 hat die SSH-Benutzernamenverarbeitung stillschweigend auf Groß-/Kleinschreibung empfindlich geändert und ssh-dss-Schlüssel deaktiviert. Vollständiger Leitfaden zur Reparatur von SSH-Verbindungen, Konfigurationsaktualisierungen und Migration zu Ed25519-Schlüsseln.

Apple hat macOS Tahoe 26.3 am 11. Februar 2026 veröffentlicht, und für Tausende von Entwicklern und Systemadministratoren brachen SSH-Verbindungen sofort zusammen. Kein Warndialog. Kein Migrationsassistent. Kein Hinweis in den Release Notes. An einem Tag konnte man noch ssh administrator@yourserver verwenden, am nächsten Tag erhielt man Connection closed by 10.10.83.28 port 22. Wer sich auf DSA-Schlüssel zur Authentifizierung gegenüber Legacy-Infrastruktur verlassen hat, konnte diese überhaupt nicht mehr verwenden. Dieser Leitfaden erklärt genau, was sich geändert hat, warum es passiert ist und wie jeder betroffene Workflow repariert werden kann — von interaktiven Sitzungen bis hin zu automatisierten CI/CD-Pipelines.

Wichtigste Erkenntnisse

  • macOS Tahoe 26.3 erzwingt Groß-/Kleinschreibung-empfindliche SSH-Benutzernamen. Die Eingabe von administrator statt Administrator führt zu einem sofortigen Verbindungsabbruch ohne Passworteingabeaufforderung.
  • ssh-dss (DSA)-Schlüssel wurden dauerhaft entfernt. OpenSSH 10.0, das mit Tahoe 26.3 gebündelt wird, hat die DSA-Unterstützung vollständig aus dem Kompilierungsschritt entfernt. Es gibt keine Konfigurationsoption, um sie wieder zu aktivieren.
  • Post-Quantum-Schlüsselaustausch-Warnungen erscheinen jetzt, wenn eine Verbindung zu Servern hergestellt wird, die mlkem768x25519-sha256 oder sntrup761x25519-sha512 nicht unterstützen.
  • Ed25519 ist der empfohlene Schlüsseltyp für alle neuen SSH-Schlüssel. Es ist schneller, sicherer und erzeugt kleinere Signaturen als RSA.
  • Jede ~/.ssh/config-Datei sollte überprüft werden auf Groß-/Kleinschreibungs-Fehler in User-Direktiven und Verweise auf ssh-dss in HostKeyAlgorithms oder PubkeyAcceptedAlgorithms.

Inhaltsverzeichnis

  1. Was sich genau in macOS Tahoe 26.3 SSH geändert hat
  2. Diagnose von SSH-Verbindungsfehlern nach dem Update
  3. Die Änderung der Groß-/Kleinschreibung verstehen
  4. Die Entfernung des DSA-Schlüssels verstehen
  5. Post-Quantum-Schlüsselaustausch-Warnungen
  6. Schritt-für-Schritt-Lösung: Groß-/Kleinschreibungsprobleme
  7. Schritt-für-Schritt-Lösung: Migration von DSA zu Ed25519
  8. Vollständiger SSH-Konfigurationsprüfungsleitfaden
  9. SSH-Agent-Änderungen und Keychain-Integration
  10. Auswirkungen auf CI/CD-Pipelines und Automatisierung
  11. Auswirkungen auf Remote-Entwicklungsworkflows
  12. Workarounds für Legacy-Infrastruktur
  13. SSH-Sicherheitsbest Practices für 2026
  14. Häufig Gestellte Fragen
  15. Fazit

Was sich genau in macOS Tahoe 26.3 SSH geändert hat

macOS Tahoe 26.3 wird mit OpenSSH 10.0 geliefert, das drei bahnbrechende Änderungen einführt, die tägliche SSH-Workflows beeinflussen. Apple hat keine dieser Änderungen in den benutzerorientierten Release Notes hervorgehoben und überließ es den Entwicklern, sie durch fehlgeschlagene Verbindungen zu entdecken.

Änderung 1: Groß-/Kleinschreibung-empfindliches Benutzernamen-Matching

Vor Tahoe 26.3 war der SSH-Client auf macOS bei der Groß-/Kleinschreibung von Benutzernamen nachsichtig. Man konnte sich mit ssh administrator@server, ssh Administrator@server oder sogar ssh ADMINISTRATOR@server verbinden, und der Remote-Server würde den Benutzernamen korrekt auflösen, solange das zugrunde liegende Betriebssystem das Konto finden konnte. Nach dem Update erzwingt der SSH-Client eine strikte Groß-/Kleinschreibungs-Übereinstimmung, bevor die Verbindung vollständig hergestellt wird. Wenn die Groß-/Kleinschreibung nicht dem entspricht, was der Remote-Server erwartet, wird die Verbindung sofort geschlossen — bevor die Passwortauthentifizierung oder der Schlüsselaustausch abgeschlossen ist.

Änderung 2: Vollständige Entfernung von DSA (ssh-dss)

OpenSSH hat DSA seit Version 7.0 im Jahr 2015 schrittweise abgekündigt. Die Abkündigung folgte einem klaren Zeitplan:

DatumOpenSSH-VersionDSA-Status
20157.0Standardmäßig deaktiviert, via Config reaktivierbar
20249.xCompile-time optional, standardmäßig aktiviert
Mitte 20249.xCompile-time optional, standardmäßig deaktiviert
April 202510.0Vollständig aus der Codebasis entfernt
Februar 202610.0 (macOS Tahoe 26.3)An alle macOS-Nutzer ausgeliefert

Mit macOS Tahoe 26.3 gibt es keinen PubkeyAcceptedAlgorithms +ssh-dss-Workaround. Der Algorithmus ist nicht in der Binärdatei vorhanden. Jede SSH-Konfiguration, die auf ssh-dss verweist, erzeugt einen Bad key types-Fehler.

Änderung 3: Post-Quantum-Schlüsselaustausch-Warnungen

OpenSSH 10.0 hat eine Warnung eingeführt, die ausgelöst wird, wenn eine Verbindung zu Servern hergestellt wird, die keine Post-Quantum-Schlüsselaustausch-Algorithmen unterstützen. Die Warnung lautet:

WARNING: connection is not using a post-quantum key exchange algorithm.
This session may be vulnerable to 'store now, decrypt later' attacks.

Obwohl es sich um eine Warnung und keinen schwerwiegenden Fehler handelt, erzeugt sie Rauschen in der Terminal-Ausgabe und kann automatisierte Skripte beschädigen, die SSH-Ausgaben parsen.

Was sich nicht geändert hat

Es ist erwähnenswert, was gleich bleibt:

  • RSA-Schlüssel funktionieren weiterhin (mit rsa-sha2-256- und rsa-sha2-512-Signaturalgorithmen)
  • ECDSA-Schlüssel funktionieren weiterhin (obwohl Ed25519 bevorzugt wird)
  • SSH-Port-Weiterleitung, Tunneling und ProxyJump funktionieren alle identisch
  • Das Format der ~/.ssh/known_hosts-Datei hat sich nicht geändert

Wenn Sie neu bei SSH auf macOS sind oder eine Entwicklungsumgebung von Grund auf einrichten, deckt unser macOS Tahoe Entwickler-Setup-Leitfaden die vollständige Erstkonfiguration ab.

Diagnose von SSH-Verbindungsfehlern nach dem Update

Bevor Sie Änderungen vornehmen, müssen Sie feststellen, welches der drei Probleme Ihre Verbindungen beeinflusst. Die ausführliche SSH-Ausgabe ist Ihr primäres Diagnosewerkzeug.

Schritt 1: Ausführliche SSH-Ausgabe aktivieren

Führen Sie Ihren fehlgeschlagenen SSH-Befehl mit dreifachen Verbose-Flags aus, um die vollständige Handshake-Verhandlung zu sehen:

ssh -vvv user@hostname

Dies erzeugt eine detaillierte Ausgabe, die jede Phase der Verbindung zeigt. Suchen Sie nach diesen spezifischen Mustern:

Muster für Fehler bei der Groß-/Kleinschreibung:

debug1: Connecting to 10.10.83.28 [10.10.83.28] port 22.
debug1: Connection established.
debug1: identity file /Users/you/.ssh/id_ed25519 type 3
debug3: receive packet: type 7
Connection closed by 10.10.83.28 port 22

Der Schlüsselindikator ist, dass die Verbindung nach dem Aufbau, aber vor jedem Authentifizierungsversuch geschlossen wird. Es gibt keine "Permission denied"-Meldung — die Verbindung bricht einfach ab.

Muster für DSA-Schlüsselfehler:

/Users/you/.ssh/config line 15: Bad key types '+ssh-dss'.

oder:

Bad key types '+ssh-rsa,ssh-dss'

Dieser Fehler erscheint sofort, wenn der SSH-Client Ihre Konfigurationsdatei parst, bevor ein Verbindungsversuch unternommen wird.

Muster für Post-Quantum-Warnung:

WARNING: connection is not using a post-quantum key exchange algorithm.
This session may be vulnerable to 'store now, decrypt later' attacks.

Dies erscheint während des Schlüsselaustauschs, verhindert aber nicht, dass die Verbindung abgeschlossen wird.

Schritt 2: Die SSH-Client-Version überprüfen

Stellen Sie fest, welche OpenSSH-Version ausgeführt wird:

ssh -V

Erwartete Ausgabe auf macOS Tahoe 26.3:

OpenSSH_10.0p1, LibreSSL 3.3.6

Wenn Sie eine ältere Version sehen, haben Sie möglicherweise ein über Homebrew installiertes OpenSSH, das Priorität hat. Überprüfen Sie, welche Binärdatei verwendet wird:

which ssh

Das System-SSH befindet sich unter /usr/bin/ssh. Wenn Sie /opt/homebrew/bin/ssh oder /usr/local/bin/ssh sehen, verwenden Sie eine Homebrew-Version, die sich möglicherweise anders verhält.

Schritt 3: Mit expliziten Parametern testen

Isolieren Sie das Problem, indem Sie mit expliziter Benutzername-Groß-/Kleinschreibung und Schlüsseltyp testen:

# Groß-/Kleinschreibung testen - beide Varianten versuchen
ssh -vvv Administrator@hostname
ssh -vvv administrator@hostname

# Ohne Konfigurationsdatei-Interferenz testen
ssh -F /dev/null -vvv user@hostname

# Mit einem bestimmten Schlüssel testen
ssh -vvv -i ~/.ssh/id_ed25519 user@hostname

Terminal SSH-Debug-Ausgabe

Schritt 4: SSH-Konfiguration auf Fehler überprüfen

Analysieren Sie Ihre Konfigurationsdatei, um Zeilen zu identifizieren, die auf veraltete Algorithmen verweisen:

# Auf ssh-dss-Referenzen prüfen
grep -n "ssh-dss" ~/.ssh/config

# Auf ssh-dss-Referenzen in der Systemkonfiguration prüfen
grep -n "ssh-dss" /etc/ssh/ssh_config

# Alle User-Direktiven zur Überprüfung der Groß-/Kleinschreibung
grep -n "User " ~/.ssh/config

Für ein tieferes Verständnis der Terminal-Nutzung auf macOS Tahoe verweisen wir auf unseren macOS Tahoe Terminal-Leitfaden.

Die Änderung der Groß-/Kleinschreibung verstehen

Warum diese Änderung Verbindungen unterbricht

Auf den meisten Unix-ähnlichen Systemen sind Benutzernamen auf Betriebssystemebene Groß-/Kleinschreibung-empfindlich. Ein Benutzer namens Administrator ist technisch gesehen ein anderes Konto als administrator. Das SSH-Protokoll selbst (RFC 4252) gibt jedoch an, dass Benutzernamen "case-sensitive" sind, erkennt aber an, dass Server-Implementierungen dies unterschiedlich handhaben können.

Vor macOS Tahoe 26.3 war der macOS SSH-Client nachsichtig. Wenn man ssh administrator@server eingab, sendete der Client den Benutzernamen so wie er war, und viele SSH-Server (insbesondere solche auf Windows, macOS oder Netzwerk-Appliances) normalisierten die Groß-/Kleinschreibung während der Authentifizierung. Die Verbindung gelang, weil der Server die schwere Arbeit leistete, administrator dem Administrator-Konto zuzuordnen.

Mit OpenSSH 10.0 führt der SSH-Client auf macOS jetzt eine strengere Vor-Authentifizierungsprüfung durch. Wenn der Server eine frühe Protokollnachricht zurückgibt, die eine Groß-/Kleinschreibungs-Nichtübereinstimmung anzeigt, wird die Verbindung beendet, bevor die Authentifizierung fortgesetzt werden kann. Das bedeutet:

  • Verbindungen zu Windows-Servern (die historisch die Groß-/Kleinschreibung normalisierten) können unterbrochen werden
  • Verbindungen zu Netzwerk-Appliances (Router, Switches, NAS-Geräte), die Groß-/Kleinschreibung-unempfindliche Benutzernamen verwenden, können unterbrochen werden
  • Verbindungen zu macOS-Servern, bei denen das Admin-Konto Administrator (großes A) ist, aber Skripte administrator (kleines a) verwenden, werden unterbrochen
  • Verbindungen zu Linux-Servern sind weniger wahrscheinlich betroffen, da Linux-Benutzernamen bereits Groß-/Kleinschreibung-empfindlich sind

Häufige Szenarien, die unterbrochen werden

Szenario 1: macOS-zu-macOS-Remote-Management

Viele Systemadministratoren verbinden sich mit Remote-Macs über:

ssh [email protected]

Aber das standardmäßige macOS-Admin-Konto wird als Administrator mit einem großen A erstellt. Dies funktionierte vor Tahoe 26.3 und schlägt danach fehl.

Szenario 2: Verwaltung von Netzwerk-Appliances

Die Verbindung zu Routern, Switches, Firewalls und NAS-Geräten verwendet häufig generische Benutzernamen:

ssh [email protected]
ssh [email protected]

Wenn das Gerät den Benutzernamen als Admin oder ROOT speichert, werden diese Verbindungen nun stillschweigend fehlschlagen.

Szenario 3: SSH-Konfigurationsaliase

Viele Entwickler haben SSH-Konfigurationseinträge mit falscher Groß-/Kleinschreibung, die zuvor funktionierten:

# ~/.ssh/config - dies kann jetzt unterbrochen werden
Host production
    HostName prod.example.com
    User deploy      # Server erwartet "Deploy"
    IdentityFile ~/.ssh/prod_key

Die Entfernung des DSA-Schlüssels verstehen

Das Sicherheitsargument gegen DSA

DSA (Digital Signature Algorithm), wie es in SSH implementiert ist, verwendet eine feste Schlüssellänge von 1024 Bit und SHA-1 für Hashing. Diese Kombination bietet etwa 80 Bit symmetrische Sicherheit — weit unter dem von modernen Sicherheitsstandards empfohlenen Minimum von 128 Bit.

Die spezifischen Schwächen von DSA-Schlüsseln:

EigenschaftDSA (ssh-dss)Ed25519RSA-4096
Schlüsselgröße1024 Bit256 Bit4096 Bit
Hash-AlgorithmusSHA-1SHA-512SHA-256/512
Sicherheitsstufe~80 Bit~128 Bit~128 Bit
Signaturgröße40 Bytes64 Bytes512 Bytes
SigniergeschwindigkeitLangsamSchnellModerat
VerifizierungsgeschwindigkeitLangsamSchnellModerat
Anfälligkeit für BiasHochKeineKeine

DSA ist besonders anfällig für Implementierungsfehler. Wenn der bei der Signierung verwendete Zufallszahlengenerator eine Verzerrung aufweist, kann der private Schlüssel aus einer kleinen Anzahl von Signaturen wiederhergestellt werden. Dies wurde bei realen Angriffen ausgenutzt.

Was "Entfernt" tatsächlich bedeutet

In früheren macOS-Versionen war DSA standardmäßig deaktiviert, konnte aber mit Konfigurationsoptionen wieder aktiviert werden:

# Dies funktionierte auf macOS Sequoia und früher
Host legacy-server
    HostKeyAlgorithms +ssh-dss
    PubkeyAcceptedAlgorithms +ssh-dss

In macOS Tahoe 26.3 verursachen diese Konfigurationszeilen selbst Fehler, da die SSH-Binärdatei ssh-dss nicht mehr als gültigen Algorithmus-Identifier erkennt. Der Fehler lautet:

/Users/you/.ssh/config line 8: Bad key types '+ssh-dss'.

Das bedeutet:

  1. Sie können keine DSA-Schlüssel für die Authentifizierung verwenden (Public-Key-Anmeldung)
  2. Sie können keine DSA-Host-Keys von Servern akzeptieren
  3. Sie können nicht einmal ssh-dss in Ihren Konfigurationsdateien referenzieren, ohne Fehler zu verursachen
  4. Das ssh-keygen-Tool kann keine DSA-Schlüssel mehr generieren

Überprüfen, ob Sie DSA-Schlüssel haben

Bevor Sie mit der Migration fortfahren, überprüfen Sie Ihre vorhandenen Schlüssel:

# Alle SSH-Schlüssel mit ihren Typen auflisten
for key in ~/.ssh/*.pub; do
    echo "=== $key ==="
    ssh-keygen -l -f "$key"
done

Beispielausgabe:

=== /Users/you/.ssh/id_dsa.pub ===
1024 SHA256:abc123... you@mac (DSA)          # Dieser Schlüssel muss ersetzt werden
=== /Users/you/.ssh/id_ed25519.pub ===
256 SHA256:xyz789... you@mac (ED25519)       # Dieser Schlüssel ist in Ordnung
=== /Users/you/.ssh/id_rsa.pub ===
3072 SHA256:def456... you@mac (RSA)          # Dieser Schlüssel ist in Ordnung

Jeder als (DSA) identifizierte Schlüssel muss ersetzt werden. Wenn Sie einen finden, löschen Sie ihn noch nicht — Sie benötigen ihn, um zu identifizieren, welche Server ihn autorisiert haben.

Post-Quantum-Schlüsselaustausch-Warnungen

Was die Warnung bedeutet

OpenSSH 10.0 hat Post-Quantum-Schlüsselaustausch mit dem ML-KEM-Algorithmus (früher CRYSTALS-Kyber) eingeführt, der mit X25519 hybridisiert ist. Der Standard-Schlüsselaustausch-Algorithmus ist jetzt mlkem768x25519-sha256, mit sntrup761x25519-sha512 als Fallback.

Bei der Verbindung zu einem Server, der keinen dieser Algorithmen unterstützt, zeigt OpenSSH an:

WARNING: connection is not using a post-quantum key exchange algorithm.
This session may be vulnerable to 'store now, decrypt later' attacks.

Ein "Jetzt speichern, später entschlüsseln"-Angriff bedeutet, dass ein Angreifer Ihren verschlüsselten SSH-Traffic heute aufzeichnen und in der Zukunft entschlüsseln könnte, wenn Quantencomputer in der Lage sind, klassische Schlüsselaustausch-Algorithmen zu brechen.

Wann Sie diese Warnung sehen werden

  • Bei der Verbindung zu Servern, die OpenSSH 8.x oder früher ausführen
  • Bei der Verbindung zu Netzwerk-Appliances mit eingebetteten SSH-Implementierungen
  • Bei der Verbindung zu Cloud-Instanzen mit älteren SSH-Daemon-Versionen
  • Bei der Verbindung zu GitHub, GitLab oder Bitbucket (können PQ-Algorithmen noch nicht unterstützen)

Die Warnung unterdrücken

Wenn Sie das Risiko verstehen und die Warnung unterdrücken möchten, fügen Sie dies zu Ihrer ~/.ssh/config hinzu:

# Post-Quantum-Warnungen global unterdrücken
Host *
    WarnWeakCrypto no

Oder nur für bestimmte Hosts:

Host legacy-server
    HostName 192.168.1.100
    WarnWeakCrypto no

Die ideale Lösung ist es, Ihre Server auf OpenSSH 9.0 oder höher zu aktualisieren, das sntrup761x25519-sha512 unterstützt, oder OpenSSH 9.9+, das das neuere mlkem768x25519-sha256 unterstützt.

Schritt-für-Schritt-Lösung: Groß-/Kleinschreibungsprobleme

Lösung 1: Die korrekte Benutzername-Groß-/Kleinschreibung ermitteln

Stellen Sie zunächst den genauen Benutzernamen auf dem Remote-System fest. Die Methode hängt vom Remote-Betriebssystem ab:

Für Remote Linux/macOS-Server:

# Wenn Sie noch über Konsole, physischen Zugang oder einen anderen SSH-Client anmelden können
grep "your_username" /etc/passwd

# Oder den id-Befehl verwenden
id

# Beispielausgabe: uid=501(Administrator) gid=20(staff) groups=...

Für Remote Windows-Server (OpenSSH):

# In PowerShell auf der Remote-Maschine
whoami
# Ausgabe: DOMAIN\Administrator

Für Netzwerk-Appliances:

Überprüfen Sie die Web-Verwaltungsschnittstelle oder Dokumentation des Geräts für das genaue Benutzernamenformat. Häufige Muster:

  • Cisco IOS: typischerweise Kleinbuchstaben (admin)
  • Juniper: typischerweise Kleinbuchstaben (root)
  • Synology NAS: Groß-/Kleinschreibung wie erstellt
  • QNAP NAS: Groß-/Kleinschreibung wie erstellt

Lösung 2: Ihre SSH-Konfigurationsdatei aktualisieren

Öffnen Sie Ihre SSH-Konfiguration und korrigieren Sie alle User-Direktiven:

# Die Konfigurationsdatei öffnen
nano ~/.ssh/config

Vorher (fehlerhaft):

Host production
    HostName prod.example.com
    User administrator
    IdentityFile ~/.ssh/prod_key

Host nas
    HostName nas.local
    User admin
    Port 22

Nachher (korrigiert):

Host production
    HostName prod.example.com
    User Administrator
    IdentityFile ~/.ssh/prod_key

Host nas
    HostName nas.local
    User Admin
    Port 22

Lösung 3: Shell-Aliase und Skripte aktualisieren

SSH-Befehle in Ihrer Shell-Konfiguration suchen:

# Bash-Aliase überprüfen
grep -n "ssh " ~/.bashrc ~/.bash_profile 2>/dev/null

# Zsh-Aliase überprüfen
grep -n "ssh " ~/.zshrc ~/.zprofile 2>/dev/null

# SSH-Befehle in benutzerdefinierten Skripten suchen
grep -rn "ssh " ~/scripts/ ~/bin/ 2>/dev/null

Aktualisieren Sie alle hardcodierten Benutzernamen, um die korrekte Groß-/Kleinschreibung zu verwenden.

Lösung 4: Umgebungsvariablen aktualisieren

Einige Tools verwenden Umgebungsvariablen für SSH-Benutzernamen:

# Auf SSH-bezogene Umgebungsvariablen prüfen
env | grep -i ssh
env | grep -i user

# Häufig zu prüfende Variablen
echo $DEPLOY_USER
echo $SSH_USER
echo $REMOTE_USER

Lösung 5: Die Korrektur verifizieren

Nach dem Vornehmen von Änderungen jede Verbindung verifizieren:

# Mit ausführlicher Ausgabe testen
ssh -v production

# Erwartet: erfolgreiche Authentifizierung
# debug1: Authentication succeeded (publickey).

Schritt-für-Schritt-Lösung: Migration von DSA zu Ed25519

Dieser Abschnitt führt durch den vollständigen Prozess des Ersetzens von DSA-Schlüsseln durch Ed25519-Schlüssel. Wenn Sie Hintergrundwissen zu Terminal-Befehlen benötigen, deckt unser Mac Terminal-Meister-Leitfaden alle Grundlagen ab.

SSH-Schlüsselmigrations-Fluss

Phase 1: Ihre DSA-Schlüssel inventarisieren

Bevor Sie neue Schlüssel generieren, dokumentieren Sie, wo Ihre DSA-Schlüssel verwendet werden:

# Schritt 1: Alle DSA-Schlüssel auf Ihrem System finden
find ~/.ssh -name "*.pub" -exec grep -l "ssh-dss" {} \;

# Schritt 2: Für jeden DSA-Schlüssel prüfen, welche Server ihn autorisieren
# Den Fingerabdruck des öffentlichen Schlüssels notieren
ssh-keygen -l -f ~/.ssh/id_dsa.pub

# Schritt 3: DSA-Host-Keys in known_hosts prüfen
grep "ssh-dss" ~/.ssh/known_hosts | awk '{print $1}'

Eine Migrations-Checkliste erstellen:

# Eine Migrations-Tracking-Datei erstellen
cat > ~/ssh_migration_checklist.txt << 'EOF'
SSH DSA-Schlüsselmigrations-Checkliste
===============================
Datum: $(date)

Gefundene DSA-Schlüssel:
- [ ] ~/.ssh/id_dsa -> Verwendet für: _______________
- [ ] ~/.ssh/id_dsa.pub -> Autorisiert auf: _______________

Server mit DSA-Host-Keys:
- [ ] server1.example.com
- [ ] 192.168.1.100

Automatisierung/Skripte, die DSA verwenden:
- [ ] deploy.sh
- [ ] backup-cron.sh
- [ ] CI/CD-Pipeline: _______________
EOF

Phase 2: Neue Ed25519-Schlüssel generieren

Ein neues Ed25519-Schlüsselpaar mit einem aussagekräftigen Kommentar generieren:

# Ed25519-Schlüssel mit beschreibendem Kommentar generieren
ssh-keygen -t ed25519 -C "yourname@macbook-2026-02" -f ~/.ssh/id_ed25519

# Sie werden nach einer Passphrase gefragt — VERWENDEN SIE EINE
# Eine Passphrase schützt Ihren privaten Schlüssel, wenn Ihr Rechner kompromittiert wird

Wenn Sie separate Schlüssel für verschiedene Zwecke benötigen (empfohlen für Sicherheitsisolierung):

# Schlüssel für Arbeitsserver
ssh-keygen -t ed25519 -C "work-servers-2026" -f ~/.ssh/id_ed25519_work

# Schlüssel für persönliche Projekte
ssh-keygen -t ed25519 -C "personal-2026" -f ~/.ssh/id_ed25519_personal

# Schlüssel für CI/CD-Automatisierung
ssh-keygen -t ed25519 -C "cicd-automation-2026" -f ~/.ssh/id_ed25519_cicd

Die generierten Schlüssel verifizieren:

# Den neuen Schlüssel überprüfen
ssh-keygen -l -f ~/.ssh/id_ed25519.pub

# Erwartete Ausgabe:
# 256 SHA256:abcdef123456... yourname@macbook-2026-02 (ED25519)

Phase 3: Neue Schlüssel auf Servern bereitstellen

Für jeden Server, der zuvor Ihren DSA-Schlüssel verwendete, den neuen Ed25519-Public-Key bereitstellen:

Methode 1: ssh-copy-id verwenden (wenn Sie sich noch authentifizieren können)

Wenn Sie eine andere funktionierende Authentifizierungsmethode haben (Passwort, anderer Schlüssel):

# Den neuen Schlüssel mit Passwort-Authentifizierung bereitstellen
ssh-copy-id -i ~/.ssh/id_ed25519.pub user@server

# Oder einen funktionierenden Schlüssel für die Authentifizierung während der Bereitstellung angeben
ssh-copy-id -i ~/.ssh/id_ed25519.pub -o "IdentityFile=~/.ssh/id_rsa" user@server

Methode 2: Manuelle Bereitstellung (wenn ssh-copy-id nicht verfügbar ist)

# Den öffentlichen Schlüsselinhalt kopieren
cat ~/.ssh/id_ed25519.pub | pbcopy

# Mit einer beliebigen funktionierenden Methode auf den Server SSHen
ssh user@server

# Auf dem Remote-Server den Schlüssel hinzufügen
mkdir -p ~/.ssh
chmod 700 ~/.ssh
echo "IHREN_ÖFFENTLICHEN_SCHLÜSSEL_HIER_EINFÜGEN" >> ~/.ssh/authorized_keys
chmod 600 ~/.ssh/authorized_keys

Methode 3: Für Server, auf die Sie nicht per SSH zugreifen können

Wenn der DSA-Schlüssel Ihre einzige Authentifizierungsmethode war und nicht mehr funktioniert:

  1. Die Web-Verwaltungskonsole des Servers verwenden (falls verfügbar)
  2. Über physische Konsole oder IPMI/iLO/iDRAC zugreifen
  3. Einen Jump-Host verwenden, der noch Zugang hat
  4. Den Server-Administrator kontaktieren

Phase 4: SSH-Konfiguration aktualisieren

DSA-Schlüsselreferenzen in Ihrer SSH-Konfiguration ersetzen:

# Vorher
Host old-server
    HostName legacy.example.com
    User admin
    IdentityFile ~/.ssh/id_dsa
    HostKeyAlgorithms +ssh-dss
    PubkeyAcceptedAlgorithms +ssh-dss

# Nachher
Host old-server
    HostName legacy.example.com
    User Admin
    IdentityFile ~/.ssh/id_ed25519_work

Phase 5: Bekannte Hosts bereinigen

Veraltete DSA-Host-Key-Einträge entfernen:

# Server mit DSA-Host-Keys in known_hosts finden
grep "ssh-dss" ~/.ssh/known_hosts

# Bestimmte Host-Einträge entfernen (der Host-Key wird bei der nächsten Verbindung neu akzeptiert)
ssh-keygen -R hostname_or_ip

# Oder alle DSA-Einträge auf einmal entfernen
# Zuerst die Datei sichern
cp ~/.ssh/known_hosts ~/.ssh/known_hosts.backup.$(date +%Y%m%d)

# Dann DSA-Einträge entfernen
grep -v "ssh-dss" ~/.ssh/known_hosts > ~/.ssh/known_hosts.tmp
mv ~/.ssh/known_hosts.tmp ~/.ssh/known_hosts

Phase 6: Alles verifizieren

Jede Server-Verbindung testen:

# Verbindungen mit ausführlicher Ausgabe testen
ssh -v old-server

# Verifizieren, dass der richtige Schlüssel angeboten wird
# Suchen nach: debug1: Offering public key: /Users/you/.ssh/id_ed25519_work ED25519

# Einen vollständigen Konnektivitätstest für alle konfigurierten Hosts durchführen
for host in $(grep "^Host " ~/.ssh/config | awk '{print $2}' | grep -v '\*'); do
    echo "Teste: $host"
    ssh -o ConnectTimeout=5 -o BatchMode=yes "$host" echo "OK" 2>&1
    echo "---"
done

Phase 7: Den DSA-Schlüssel außer Dienst stellen

Sobald alle Server migriert und verifiziert sind:

# Alte DSA-Schlüssel archivieren (nicht sofort löschen)
mkdir -p ~/.ssh/deprecated
mv ~/.ssh/id_dsa ~/.ssh/deprecated/id_dsa.retired.$(date +%Y%m%d)
mv ~/.ssh/id_dsa.pub ~/.ssh/deprecated/id_dsa.pub.retired.$(date +%Y%m%d)
chmod 400 ~/.ssh/deprecated/id_dsa.retired.*

Bewahren Sie die archivierten Schlüssel mindestens 90 Tage lang auf, falls Sie einen übersehenen Server entdecken.

Vollständiger SSH-Konfigurationsprüfungsleitfaden

Nach dem Beheben einzelner Probleme eine vollständige Überprüfung Ihrer SSH-Konfiguration durchführen. Dies ist besonders wichtig, wenn Sie SSH auf macOS seit Jahren verwenden und Konfigurationseinträge über mehrere macOS-Upgrades hinweg angesammelt haben.

Audit-Schritt 1: Auf veraltete Algorithmen prüfen

# Auf JEGLICHE veraltete Algorithmus-Referenzen prüfen
echo "=== ~/.ssh/config überprüfen ==="
grep -n -E "(ssh-dss|ssh-dsa|diffie-hellman-group1-sha1|diffie-hellman-group14-sha1|hmac-sha1-96|hmac-md5)" ~/.ssh/config 2>/dev/null

echo ""
echo "=== /etc/ssh/ssh_config überprüfen ==="
grep -n -E "(ssh-dss|ssh-dsa|diffie-hellman-group1-sha1)" /etc/ssh/ssh_config 2>/dev/null

echo ""
echo "=== /etc/ssh/ssh_config.d/ überprüfen ==="
grep -rn -E "(ssh-dss|ssh-dsa)" /etc/ssh/ssh_config.d/ 2>/dev/null

Audit-Schritt 2: Konfigurationssyntax validieren

# SSH-Konfigurationssyntax ohne Verbindung testen
ssh -G test-host 2>&1 | head -5

# Bei Fehlern erscheinen diese als:
# /Users/you/.ssh/config line X: Bad key types '...'

Audit-Schritt 3: Alle User-Direktiven überprüfen

# Alle User-Direktiven und die Hosts, auf die sie zutreffen, extrahieren
awk '/^Host /{host=$2} /User /{print host, $0}' ~/.ssh/config

Die Ausgabe überprüfen und die Groß-/Kleinschreibung jedes Benutzernamens verifizieren.

Audit-Schritt 4: Dateiberechtigungen prüfen

SSH ist streng bei Dateiberechtigungen. Falsche Berechtigungen können zu stillen Fehlern führen:

# SSH-Verzeichnisberechtigungen überprüfen und korrigieren
echo "=== Verzeichnisberechtigungen ==="
ls -la ~/.ssh/

echo ""
echo "=== Erwartete Berechtigungen ==="
echo "~/.ssh/           -> drwx------ (700)"
echo "~/.ssh/config     -> -rw------- (600)"
echo "~/.ssh/id_*       -> -rw------- (600) für private Schlüssel"
echo "~/.ssh/*.pub      -> -rw-r--r-- (644) für öffentliche Schlüssel"
echo "~/.ssh/authorized_keys -> -rw------- (600)"
echo "~/.ssh/known_hosts     -> -rw-r--r-- (644)"

# Berechtigungen korrigieren, falls nötig
chmod 700 ~/.ssh
chmod 600 ~/.ssh/config 2>/dev/null
chmod 600 ~/.ssh/id_* 2>/dev/null
chmod 644 ~/.ssh/*.pub 2>/dev/null
chmod 600 ~/.ssh/authorized_keys 2>/dev/null

Audit-Schritt 5: Empfohlene moderne SSH-Konfigurationsvorlage

Hier ist eine vollständige, moderne SSH-Konfigurationsvorlage, die mit macOS Tahoe 26.3 funktioniert:

# ~/.ssh/config
# Aktualisiert für macOS Tahoe 26.3 / OpenSSH 10.0
# Zuletzt geprüft: 2026-02-28

# ============================================
# Globale Standardwerte
# ============================================
Host *
    # Standardmäßig Ed25519-Schlüssel verwenden
    IdentityFile ~/.ssh/id_ed25519

    # Nur explizit für jeden Host konfigurierte Schlüssel anbieten
    IdentitiesOnly yes

    # macOS Keychain-Integration
    UseKeychain yes
    AddKeysToAgent yes

    # Moderne Schlüsselaustausch-Einstellungen
    KexAlgorithms mlkem768x25519-sha256,[email protected],curve25519-sha256,[email protected]

    # Verbindungsstabilität
    ServerAliveInterval 60
    ServerAliveCountMax 3

    # Sicherheitshärtung
    HashKnownHosts yes
    StrictHostKeyChecking ask

# ============================================
# Arbeitsserver
# ============================================
Host prod-web
    HostName prod-web.example.com
    User Deploy
    IdentityFile ~/.ssh/id_ed25519_work
    Port 22

Host staging
    HostName staging.example.com
    User Deploy
    IdentityFile ~/.ssh/id_ed25519_work
    Port 22

# ============================================
# Persönliche Server
# ============================================
Host homelab
    HostName 192.168.1.100
    User admin
    IdentityFile ~/.ssh/id_ed25519_personal

# ============================================
# Jump-Host-Konfiguration
# ============================================
Host internal-*
    ProxyJump bastion.example.com
    User admin
    IdentityFile ~/.ssh/id_ed25519_work

Host bastion.example.com
    User jump-user
    IdentityFile ~/.ssh/id_ed25519_work
    ForwardAgent no

SSH-Agent-Änderungen und Keychain-Integration

macOS Tahoe 26.3 bringt auch subtile Änderungen daran, wie der SSH-Agent mit dem macOS Keychain interagiert.

Keychain-Integration

Die macOS-spezifische UseKeychain-Direktive funktioniert in Tahoe 26.3 weiterhin, aber ihr Verhalten wurde verfeinert:

# Ihren neuen Ed25519-Schlüssel zum macOS Keychain hinzufügen
ssh-add --apple-use-keychain ~/.ssh/id_ed25519

# Verifizieren, dass der Schlüssel hinzugefügt wurde
ssh-add -l

Wenn der Schlüssel erfolgreich hinzugefügt wurde, sehen Sie:

256 SHA256:abcdef123456... yourname@macbook-2026-02 (ED25519)

Persistentes Laden von Schlüsseln

Stellen Sie sicher, dass Ihre SSH-Konfiguration diese Direktiven enthält, um die Schlüsselpersistenz über Neustarts hinweg aufrechtzuerhalten:

Host *
    UseKeychain yes
    AddKeysToAgent yes
    IdentityFile ~/.ssh/id_ed25519

Ohne UseKeychain yes müssen Sie nach jedem Neustart ssh-add ausführen.

Den SSH-Agent überprüfen

# Prüfen, ob der Agent läuft
echo $SSH_AUTH_SOCK

# Geladene Schlüssel auflisten
ssh-add -l

# Falls keine Schlüssel geladen sind, sie hinzufügen
ssh-add --apple-use-keychain ~/.ssh/id_ed25519

Für weitere Details zu macOS-Sicherheitskonfigurationen lesen Sie unseren macOS Tahoe Sicherheits-Datenschutz-Leitfaden.

Auswirkungen auf CI/CD-Pipelines und Automatisierung

Die SSH-Änderungen in macOS Tahoe 26.3 haben erhebliche Auswirkungen auf automatisierte Workflows. Wenn Ihre CI/CD-Pipeline auf macOS-Runnern läuft (GitHub Actions, GitLab CI, Jenkins auf Mac), werden diese Änderungen Sie nach dem Upgrade des Runner-Betriebssystems betreffen.

GitHub Actions

Wenn Sie macos-latest- oder macos-15-Runner verwenden, wird die SSH-Binärdatei schließlich aktualisiert. Prüfen Sie Ihre Workflows jetzt:

# .github/workflows/deploy.yml
# VORHER (potenziell fehlerhaft)
- name: Deploy
  run: |
    ssh administrator@${{ secrets.DEPLOY_HOST }} "cd /app && git pull"

# NACHHER (korrigiert)
- name: Deploy
  run: |
    ssh Administrator@${{ secrets.DEPLOY_HOST }} "cd /app && git pull"

Überprüfen Sie Ihre Deployment-Secrets:

  • DEPLOY_USER — verifizieren, dass die Groß-/Kleinschreibung mit dem Remote-Konto übereinstimmt
  • SSH_PRIVATE_KEY — verifizieren, dass es kein DSA-Schlüssel ist
  • KNOWN_HOSTS — verifizieren, dass keine DSA-Host-Key-Einträge vorhanden sind

GitLab CI

# .gitlab-ci.yml
deploy:
  before_script:
    # Schlüsseltyp vor dem Deployment prüfen
    - ssh-keygen -l -f ~/.ssh/id_deploy
    # Sicherstellen, dass es KEIN DSA ist
    - |
      if ssh-keygen -l -f ~/.ssh/id_deploy | grep -q "DSA"; then
        echo "FEHLER: DSA-Schlüssel erkannt. Migration erforderlich."
        exit 1
      fi
  script:
    # Korrekte Groß-/Kleinschreibung für den Benutzernamen verwenden
    - ssh -o StrictHostKeyChecking=no Deploy@$DEPLOY_HOST "deploy.sh"

Jenkins

Für Jenkins-Pipelines, die auf macOS-Agenten laufen:

pipeline {
    agent { label 'macos' }
    stages {
        stage('Pre-flight SSH Check') {
            steps {
                sh '''
                    # SSH-Version verifizieren
                    ssh -V

                    # DSA-Schlüssel in Credentials prüfen
                    for key in ~/.ssh/*.pub; do
                        if ssh-keygen -l -f "$key" | grep -q "DSA"; then
                            echo "WARNUNG: DSA-Schlüssel gefunden: $key"
                            exit 1
                        fi
                    done

                    echo "SSH-Vorflug-Prüfung bestanden"
                '''
            }
        }
    }
}

Ansible Playbooks

Wenn Sie Ansible von einem macOS-Steuerknoten aus ausführen:

# ansible.cfg
[defaults]
# Korrekte SSH-Binärdatei sicherstellen
ssh_executable = /usr/bin/ssh

# Bestimmte SSH-Argumente erzwingen
[ssh_connection]
ssh_args = -o IdentitiesOnly=yes -o IdentityFile=~/.ssh/id_ed25519_ansible

Überprüfen Sie die Groß-/Kleinschreibung der Benutzernamen in Ihrem Ansible-Inventar:

# inventory.ini
# VORHER
[webservers]
web1.example.com ansible_user=administrator

# NACHHER
[webservers]
web1.example.com ansible_user=Administrator

Automatisierte Backup-Skripte

Überprüfen Sie alle Cron-Jobs oder launchd-Tasks, die SSH verwenden:

# Alle Cron-Jobs mit SSH-Referenzen finden
crontab -l 2>/dev/null | grep -i ssh

# launchd-Plists mit SSH-Referenzen finden
grep -rl "ssh" ~/Library/LaunchAgents/ /Library/LaunchAgents/ /Library/LaunchDaemons/ 2>/dev/null

# Rsync-Backup-Skripte prüfen (rsync verwendet SSH standardmäßig)
grep -rn "rsync.*@" ~/scripts/ ~/bin/ 2>/dev/null

Auswirkungen auf Remote-Entwicklungsworkflows

VS Code Remote SSH

Die Remote SSH-Erweiterung von Visual Studio Code speichert Verbindungskonfigurationen, die möglicherweise betroffen sind:

# VS Code SSH-Konfigurationsort
cat ~/Library/Application\ Support/Code/User/settings.json | grep -A5 "remote.SSH"

# VS Code-SSH-Konfigurationsreferenzen prüfen
grep -n "ssh" ~/Library/Application\ Support/Code/User/settings.json 2>/dev/null

Aktualisieren Sie Ihre VS Code-SSH-Ziele, um die korrekte Benutzername-Groß-/Kleinschreibung und Nicht-DSA-Schlüssel zu verwenden.

JetBrains Gateway / Remote-Entwicklung

JetBrains-IDEs speichern SSH-Konfigurationen separat:

# JetBrains-SSH-Konfigurationen prüfen
find ~/Library/Application\ Support/JetBrains -name "*.xml" -exec grep -l "ssh" {} \; 2>/dev/null

tmux und persistente Sitzungen

Wenn Sie tmux oder screen über SSH verwenden, müssen Ihre Reconnect-Skripte aktualisiert werden:

# Häufiger tmux-Reconnect-Alias - Benutzername-Groß-/Kleinschreibung prüfen
alias tm='ssh -t Administrator@server "tmux attach || tmux new"'

Für eine umfassende Entwicklerumgebungs-Einrichtung lesen Sie unseren macOS Tahoe Entwickler-Ultimativen-Leitfaden.

Workarounds für Legacy-Infrastruktur

Einige Umgebungen können nicht sofort aktualisiert werden. Netzwerk-Appliances, eingebettete Systeme und Legacy-Server könnten jahrelang DSA benötigen. Hier sind praktische Workarounds, geordnet von am meisten bis am wenigsten empfohlen.

Workaround 1: Einen Jump-Host verwenden (Empfohlen)

Einen Linux-Bastion-Host einrichten, der noch DSA unterstützt, und ihn als Proxy verwenden:

# ~/.ssh/config
Host legacy-device
    HostName 192.168.1.1
    User admin
    ProxyJump bastion

Host bastion
    HostName bastion.example.com
    User jump
    IdentityFile ~/.ssh/id_ed25519

Der Bastion-Host führt ein älteres OpenSSH (oder eines, das mit DSA-Unterstützung kompiliert wurde) aus und handelt die DSA-Verhandlung mit dem Legacy-Gerät aus. Ihr Mac muss sich nur mit Ed25519 beim Bastion authentifizieren.

Workaround 2: Einen Docker-Container verwenden

Einen älteren OpenSSH-Client innerhalb eines Docker-Containers ausführen:

# Ein Dockerfile für Legacy-SSH erstellen
cat > ~/legacy-ssh/Dockerfile << 'EOF'
FROM alpine:3.18
RUN apk add --no-cache openssh-client
ENTRYPOINT ["ssh"]
EOF

# Bauen
docker build -t legacy-ssh ~/legacy-ssh/

# Verwenden, um sich mit Legacy-Geräten zu verbinden
docker run --rm -it \
    -v ~/.ssh:/root/.ssh:ro \
    legacy-ssh \
    -o HostKeyAlgorithms=+ssh-dss \
    -o PubkeyAcceptedKeyTypes=+ssh-dss \
    admin@legacy-device

Einen Shell-Alias für Bequemlichkeit erstellen:

# Zu ~/.zshrc hinzufügen
alias legacy-ssh='docker run --rm -it -v ~/.ssh:/root/.ssh:ro legacy-ssh'

# Verwendung
legacy-ssh -o HostKeyAlgorithms=+ssh-dss admin@legacy-device

Workaround 3: Älteres OpenSSH über Homebrew installieren

Sie können OpenSSH 9.7p1 (die letzte Version mit DSA-Unterstützung) aus den Quellen kompilieren:

# Abhängigkeiten installieren
brew install openssl@3

# OpenSSH 9.7p1-Quelle herunterladen
curl -O https://cdn.openbsd.org/pub/OpenBSD/OpenSSH/portable/openssh-9.7p1.tar.gz
tar xzf openssh-9.7p1.tar.gz
cd openssh-9.7p1

# Mit DSA-Unterstützung und benutzerdefiniertem Präfix konfigurieren
./configure \
    --prefix=$HOME/openssh97 \
    --with-ssl-dir=$(brew --prefix openssl@3)

# Bauen und installieren
make -j$(sysctl -n hw.ncpu)
make install

# Die ältere SSH-Binärdatei verwenden
~/openssh97/bin/ssh -o HostKeyAlgorithms=+ssh-dss admin@legacy-device

Einen Alias für Legacy-Verbindungen erstellen:

# Zu ~/.zshrc hinzufügen
alias ssh-legacy='~/openssh97/bin/ssh -o HostKeyAlgorithms=+ssh-dss -o PubkeyAcceptedKeyTypes=+ssh-dss'

# Verwendung
ssh-legacy admin@old-router

Workaround 4: Eine Linux-Virtuelle-Maschine verwenden

Wenn Sie UTM, Parallels oder VMware Fusion verwenden:

  1. Eine leichtgewichtige Linux-VM (Alpine oder Ubuntu Server) einrichten
  2. Von Ihrem Mac per SSH zur VM verbinden (mit Ed25519)
  3. Von der VM per SSH zum Legacy-Gerät verbinden (mit DSA)

Dies bietet vollständige Isolation und erfordert keine Änderung Ihrer macOS-SSH-Installation.

Langfristig: Geräteaustausch planen

Wenn Sie auf DSA angewiesen sind, weil Ihre Netzwerk-Appliances keine modernen Algorithmen unterstützen, ist das ein klares Signal, dass diese Geräte aus sicherheitstechnischer Sicht ihr Lebensende erreicht haben. Planen Sie einen Austauschtimeline:

  • Router/Switches: Die meisten Enterprise-Anbieter unterstützen Ed25519 seit 2018
  • NAS-Geräte: Synology, QNAP und TrueNAS unterstützen alle Ed25519
  • Legacy-Server: Wenn Sie OpenSSH älter als 6.5 ausführen, muss das gesamte System aktualisiert werden

SSH-Sicherheitsbest Practices für 2026

Mit den macOS Tahoe 26.3-Änderungen als Katalysator ist jetzt ein guter Zeitpunkt, umfassende SSH-Sicherheitsverbesserungen zu implementieren.

Best Practices für die Schlüsselverwaltung

1. Separate Schlüssel für separate Rollen verwenden:

# Arbeitsinfrastruktur
ssh-keygen -t ed25519 -f ~/.ssh/id_ed25519_work -C "work-2026"

# Persönliche Projekte
ssh-keygen -t ed25519 -f ~/.ssh/id_ed25519_personal -C "personal-2026"

# CI/CD und Automatisierung
ssh-keygen -t ed25519 -f ~/.ssh/id_ed25519_automation -C "automation-2026"

# Git-Hosting (GitHub, GitLab)
ssh-keygen -t ed25519 -f ~/.ssh/id_ed25519_git -C "git-2026"

2. Immer eine Passphrase verwenden:

Eine Passphrase verschlüsselt Ihren privaten Schlüssel im Ruhezustand. Wenn Ihr Rechner kompromittiert wird, kann der Angreifer Ihre SSH-Schlüssel nicht ohne die Passphrase verwenden. In Kombination mit der macOS Keychain-Integration müssen Sie die Passphrase nur einmal eingeben.

# Wenn bei der Schlüsselgenerierung aufgefordert:
Enter passphrase (empty for no passphrase): [eine starke Passphrase eingeben]
Enter same passphrase again: [bestätigen]

3. Schlüssel jährlich rotieren:

Schließen Sie das Jahr in Ihre Schlüssel-Kommentare ein, damit Sie wissen, wann sie generiert wurden:

ssh-keygen -t ed25519 -C "you@company-2026-Q1" -f ~/.ssh/id_ed25519_work_2026

Wenn das Jahr wechselt, neue Schlüssel generieren, deployen und alte außer Dienst stellen.

4. Korrekte Dateiberechtigungen setzen:

# Private Schlüssel: nur Eigentümer-Lesezugriff
chmod 400 ~/.ssh/id_ed25519*
chmod 600 ~/.ssh/id_ed25519*.pub

# Eigentlich können öffentliche Schlüssel von jedem gelesen werden
chmod 644 ~/.ssh/id_ed25519*.pub

# Das SSH-Verzeichnis selbst
chmod 700 ~/.ssh

# Konfigurationsdatei
chmod 600 ~/.ssh/config

Server-seitige Härtung

Wenn Sie SSH-Server verwalten, nutzen Sie diese Gelegenheit zur Härtung:

# /etc/ssh/sshd_config empfohlene Einstellungen

# Passwort-Authentifizierung deaktivieren (nur Schlüssel verwenden)
PasswordAuthentication no

# Root-Anmeldung deaktivieren
PermitRootLogin no

# Nur bestimmte Benutzer erlauben
AllowUsers deploy admin

# Modernen Schlüsselaustausch verwenden
KexAlgorithms mlkem768x25519-sha256,[email protected],curve25519-sha256

# Moderne Host-Key-Algorithmen verwenden
HostKeyAlgorithms ssh-ed25519,rsa-sha2-512,rsa-sha2-256

# Moderne Ciphers verwenden
Ciphers [email protected],[email protected],[email protected]

# Moderne MACs verwenden
MACs [email protected],[email protected]

# Ratenbegrenzung
MaxAuthTries 3
MaxSessions 5
LoginGraceTime 30

Nach der Änderung von sshd_config immer vor dem Trennen der Verbindung testen:

# Die Konfiguration validieren
sudo sshd -t

# Wenn keine Fehler, sshd neu starten
sudo systemctl restart sshd

# WICHTIG: Halten Sie Ihre aktuelle Sitzung offen und testen Sie mit einer NEUEN Verbindung
# bevor Sie die vorhandene schließen

Überwachung und Alarme

Überwachung für SSH-Authentifizierungsereignisse einrichten:

# auth.log auf fehlgeschlagene Versuche überwachen (Linux-Server)
tail -f /var/log/auth.log | grep "sshd"

# macOS-Systemprotokoll auf SSH-Ereignisse überwachen
log stream --predicate 'process == "sshd"' --level info

Fehlerbehebung häufiger Fehler

Fehler: "Connection closed by X.X.X.X port 22"

Ursache: Groß-/Kleinschreibungs-Fehler beim Benutzernamen.

Lösung:

# Den richtigen Benutzernamen ermitteln
ssh -vvv user@host 2>&1 | grep "debug1: Sending"

# Die entgegengesetzte Groß-/Kleinschreibung versuchen
ssh Administrator@host  # wenn 'administrator' fehlgeschlagen ist
ssh administrator@host  # wenn 'Administrator' fehlgeschlagen ist

Fehler: "Bad key types '+ssh-dss'"

Ursache: Die SSH-Konfiguration verweist auf den entfernten DSA-Algorithmus.

Lösung:

# Die problematische Zeile finden und bearbeiten
grep -n "ssh-dss" ~/.ssh/config

# Die Algorithmus-Referenz entfernen oder ersetzen
# Vorher: HostKeyAlgorithms +ssh-dss
# Nachher:  (die gesamte Zeile entfernen oder durch moderne Algorithmen ersetzen)

Fehler: "Bad key types '+ssh-rsa,ssh-dss'"

Ursache: Die SSH-Konfiguration hat eine zusammengesetzte Algorithmusliste einschließlich DSA.

Lösung:

# Vorher
HostKeyAlgorithms +ssh-rsa,ssh-dss
PubkeyAcceptedAlgorithms +ssh-rsa,ssh-dss

# Nachher (ssh-dss entfernen, ssh-rsa für Legacy-RSA behalten, falls nötig)
HostKeyAlgorithms +ssh-rsa
PubkeyAcceptedAlgorithms +ssh-rsa

Hinweis: ssh-rsa (mit SHA-1-Signaturen) ist ebenfalls veraltet. Wenn Sie RSA verwenden müssen, nutzen Sie rsa-sha2-256 oder rsa-sha2-512:

HostKeyAlgorithms rsa-sha2-512,rsa-sha2-256
PubkeyAcceptedAlgorithms rsa-sha2-512,rsa-sha2-256

Fehler: "No matching host key type found"

Ursache: Der Remote-Server bietet nur DSA-Host-Keys an.

Lösung: Dies erfordert Maßnahmen auf der Server-Seite. Neue Host-Keys auf dem Server generieren:

# Auf dem Remote-Server (wenn Sie Konsolenzugang haben)
sudo ssh-keygen -t ed25519 -f /etc/ssh/ssh_host_ed25519_key -N ""
sudo ssh-keygen -t rsa -b 4096 -f /etc/ssh/ssh_host_rsa_key -N ""
sudo systemctl restart sshd

Wenn Sie den Server nicht aktualisieren können, verwenden Sie die oben beschriebenen Jump-Host- oder Docker-Workarounds.

Fehler: "WARNING: connection is not using a post-quantum key exchange algorithm"

Ursache: Der Remote-Server unterstützt keinen Post-Quantum-Schlüsselaustausch.

Lösung:

# Für einen bestimmten Host unterdrücken
# Zu ~/.ssh/config hinzufügen:
Host old-server
    WarnWeakCrypto no

# Oder global unterdrücken (nicht empfohlen)
Host *
    WarnWeakCrypto no

Fehler: "Permission denied (publickey)"

Ursache: Nach der Schlüsselmigration ist der neue Schlüssel auf dem Server nicht autorisiert.

Lösung:

# Prüfen, welcher Schlüssel angeboten wird
ssh -v user@host 2>&1 | grep "Offering public key"

# Den richtigen Schlüssel deployen
ssh-copy-id -i ~/.ssh/id_ed25519.pub user@host

Fehler: "WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED"

Ursache: Nach dem Entfernen von DSA-Host-Key-Einträgen aus known_hosts bietet der Server einen anderen Host-Key-Typ an.

Lösung:

# Den alten Host-Key-Eintrag entfernen
ssh-keygen -R hostname

# Erneut verbinden und den neuen Host-Key akzeptieren
ssh user@hostname
# Sie werden aufgefordert, den Fingerabdruck des neuen Host-Keys zu verifizieren

Den breiteren Kontext verstehen

Die SSH-Änderungen in macOS Tahoe 26.3 sind Teil eines größeren branchenweiten Trends. Das Verständnis dieses Kontexts hilft Ihnen, sich auf zukünftige Änderungen vorzubereiten, anstatt auf jede zu reagieren.

OpenSSH-Versions-Zeitlinie

VersionDatumWichtige Änderungen
7.02015DSA standardmäßig deaktiviert
8.22020SHA-1-Signaturen für RSA veraltet
8.82022SHA-1-RSA-Signaturen standardmäßig deaktiviert
9.02022Post-Quantum-KEx (sntrup761) standardmäßig aktiviert
9.92024ML-KEM Post-Quantum-Unterstützung hinzugefügt
10.02025DSA vollständig entfernt, ML-KEM als Standard

macOS hat diesen Versionen historisch um 6-12 Monate nachgehinkt, was erklärt, warum die DSA-Entfernung macOS-Benutzer Anfang 2026 trifft, obwohl sie seit April 2025 in OpenSSH 10.0 ist.

Was als Nächstes zu erwarten ist

Basierend auf der OpenSSH-Entwicklungs-Roadmap:

  • SHA-1-RSA-Signaturen (ssh-rsa) werden wahrscheinlich vollständig in OpenSSH 11.x entfernt
  • ECDSA mit NIST-Kurven könnte zugunsten von Ed25519 veraltet werden
  • Post-Quantum-Signaturen (nicht nur Schlüsselaustausch) werden hinzugefügt
  • Zertifikat-basierte Authentifizierung wird zunehmend gegenüber rohen öffentlichen Schlüsseln gefördert

Jetzt vorbereiten:

  1. Sicherstellen, dass alle Schlüssel Ed25519 sind
  2. Zu rsa-sha2-256/512 wechseln, wenn RSA verwendet werden muss
  3. Post-Quantum-Schlüsselaustausch mit Ihren Servern testen
  4. SSH-Zertifikatsinfrastruktur für Ihre Organisation evaluieren

Für weitere Details zu den Änderungen im breiteren macOS Tahoe 26.3-Update lesen Sie unseren macOS Tahoe 26.3 Release-Leitfaden.

Schnellreferenz: Benötigte Befehle

Hier ist eine konsolidierte Referenz jedes in diesem Leitfaden erwähnten Befehls, nach Aufgaben organisiert:

Diagnose

# SSH-Version prüfen
ssh -V

# Ausführlicher Verbindungstest
ssh -vvv user@host

# Prüfen, welche SSH-Binärdatei läuft
which ssh

# Ohne Konfigurationsdatei testen
ssh -F /dev/null user@host

# Aktuelle Schlüsseltypen prüfen
for key in ~/.ssh/*.pub; do
    echo "=== $key ==="
    ssh-keygen -l -f "$key"
done

Schlüsselgenerierung

# Ed25519-Schlüssel generieren (empfohlen)
ssh-keygen -t ed25519 -C "description-YYYY" -f ~/.ssh/id_ed25519

# RSA-Schlüssel generieren (wenn Ed25519 vom Ziel nicht unterstützt wird)
ssh-keygen -t rsa -b 4096 -C "description-YYYY" -f ~/.ssh/id_rsa

Schlüsseldeployment

# Schlüssel auf Remote-Server deployen
ssh-copy-id -i ~/.ssh/id_ed25519.pub user@host

# Schlüssel zum macOS Keychain hinzufügen
ssh-add --apple-use-keychain ~/.ssh/id_ed25519

Konfigurationsaudit

# DSA-Referenzen in der Konfiguration finden
grep -n "ssh-dss" ~/.ssh/config /etc/ssh/ssh_config

# Alle User-Direktiven finden
grep -n "User " ~/.ssh/config

# Konfigurationssyntax validieren
ssh -G test-host

# Berechtigungen korrigieren
chmod 700 ~/.ssh
chmod 600 ~/.ssh/config
chmod 400 ~/.ssh/id_*
chmod 644 ~/.ssh/*.pub

Bereinigung

# Alten Host-Key entfernen
ssh-keygen -R hostname

# Alle DSA-Einträge aus known_hosts entfernen
cp ~/.ssh/known_hosts ~/.ssh/known_hosts.bak
grep -v "ssh-dss" ~/.ssh/known_hosts > ~/.ssh/known_hosts.tmp
mv ~/.ssh/known_hosts.tmp ~/.ssh/known_hosts

Häufig Gestellte Fragen

Kann ich OpenSSH auf macOS Tahoe 26.3 downgraden, um die DSA-Unterstützung wiederherzustellen?

Sie können die System-OpenSSH-Binärdatei auf macOS aufgrund des System Integrity Protection (SIP) nicht ersetzen. Sie können jedoch eine ältere Version über Homebrew installieren oder aus den Quellen an einem benutzerdefinierten Ort kompilieren. Das System-ssh unter /usr/bin/ssh wird immer die OpenSSH 10.0-Version sein, die mit Tahoe 26.3 geliefert wurde. Detaillierte Anweisungen zum Bauen von OpenSSH 9.7p1 aus den Quellen finden Sie im Abschnitt "Workarounds für Legacy-Infrastruktur".

Ist die Änderung der Benutzername-Groß-/Kleinschreibung dauerhaft oder ein Bug?

Basierend auf den OpenSSH 10.0-Release-Notes und der Richtung des Projekts scheint dies ein absichtliches Verhalten zu sein, das sich an der SSH-Protokollspezifikation (RFC 4252) ausrichtet, die Benutzernamen als Groß-/Kleinschreibung-empfindlich definiert. Apple hat sich nicht dazu geäußert, ob dies ein Bug ist, und es gibt keinen Hinweis darauf, dass es rückgängig gemacht wird. Sie sollten dies als dauerhaftes Verhalten behandeln und Ihre Konfigurationen entsprechend aktualisieren.

Werden meine RSA-Schlüssel auch aufhören zu funktionieren?

RSA-Schlüssel mit SHA-2-Signaturen (rsa-sha2-256 und rsa-sha2-512) funktionieren weiterhin und werden auf absehbare Zeit unterstützt. RSA-Schlüssel mit SHA-1-Signaturen (ssh-rsa) sind jedoch seit OpenSSH 8.8 standardmäßig deaktiviert und werden wahrscheinlich in einer zukünftigen Version vollständig entfernt. Wenn Sie RSA-Schlüssel verwenden, stellen Sie sicher, dass sie mindestens 3072 Bit haben und Ihre Server SHA-2-Signaturen akzeptieren. Für neue Schlüssel ist Ed25519 die bevorzugte Wahl.

Wie repariere ich SSH-Verbindungen von macOS zu Windows Server?

Die OpenSSH-Implementierung von Windows Server war historisch gesehen bei Benutzernamen nicht Groß-/Kleinschreibung-empfindlich. Nach dem macOS Tahoe 26.3-Update müssen Sie die genaue Groß-/Kleinschreibung verwenden, die Windows erkennt. Verwenden Sie für Domänenkonten DOMAIN\Username oder [email protected]. Überprüfen Sie für lokale Konten den Kontonamen in der Computerverwaltung. Aktualisieren Sie Ihre ~/.ssh/config entsprechend:

Host windows-server
    HostName win.example.com
    User DOMAIN\\AdminUser
    IdentityFile ~/.ssh/id_ed25519

Betrifft das auch SFTP und SCP?

Ja. Sowohl sftp als auch scp verwenden dieselbe SSH-Client-Bibliothek und unterliegen derselben Groß-/Kleinschreibungs-Erzwingung und DSA-Entfernung. Jeder SFTP-Client (wie Cyberduck, Transmit oder FileZilla), der die System-SSH-Binärdatei verwendet, ist ebenfalls betroffen. GUI-SFTP-Clients, die ihre eigene SSH-Bibliothek bündeln (wie Cyberduck mit seinem eigenen libssh2-Build), sind möglicherweise nicht betroffen, aber das hängt von der spezifischen Anwendung ab.

Fazit

macOS Tahoe 26.3 hat SSH-Änderungen geliefert, die etablierte Workflows ohne angemessene Warnung gebrochen haben. Die Durchsetzung von Groß-/Kleinschreibung-empfindlichen Benutzernamen, die vollständige DSA-Entfernung und die Post-Quantum-Schlüsselaustausch-Warnungen erfordern jeweils Aufmerksamkeit, aber alle sind einfach zu beheben, sobald Sie verstehen, was sich geändert hat.

Die unmittelbaren Maßnahmen sind:

  1. Ihre ~/.ssh/config überprüfen auf Groß-/Kleinschreibungs-Fehler in User-Direktiven und alle ssh-dss-Referenzen entfernen
  2. Ed25519-Schlüssel generieren, um verbleibende DSA-Schlüssel zu ersetzen
  3. Die neuen Schlüssel deployen auf alle Server in Ihrem Inventar
  4. Automatisierungsskripte und CI/CD-Pipelines aktualisieren mit korrekter Benutzername-Groß-/Kleinschreibung und Schlüsselpfaden
  5. Post-Quantum-Warnungen basierend auf Ihrer Sicherheitslage stummschalten oder beheben

Diese Änderungen, obwohl disruptiv, treiben das macOS-SSH-Ökosystem in Richtung stärkerer Sicherheitsstandards. Ed25519 ist schneller, sicherer und erzeugt kleinere Schlüssel als DSA. Groß-/Kleinschreibung-empfindliche Benutzernamen entsprechen der SSH-Protokollspezifikation. Post-Quantum-Schlüsselaustausch schützt vor zukünftigen Bedrohungen. Der Schmerz der Migration ist real, aber die Sicherheitsverbesserungen sind substanziell.

Wenn Sie eine neue Entwicklungsumgebung auf macOS Tahoe einrichten, beginnen Sie mit unserem macOS Tahoe Entwickler-Setup-Leitfaden, um alles von Anfang an korrekt zu konfigurieren. Für eine umfassendere Sicherheitskonfiguration deckt unser macOS Tahoe Sicherheits-Datenschutz-Leitfaden den vollständigen Sicherheitsstack über SSH hinaus ab.