macOS Tahoe 26.3 a Cassé SSH : Changements de Sensibilité à la Casse, Suppression des Clés DSA et Guide de Correction Complet

Q: Mes clés RSA cesseront-elles également de fonctionner ?

Les clés RSA avec signatures SHA-2 (rsa-sha2-256 et rsa-sha2-512) continuent de fonctionner et seront prises en charge dans un avenir prévisible. Cependant, les clés RSA avec signatures SHA-1 (ssh-rsa) ont été désactivées par défaut depuis OpenSSH 8.8 et seront probablement entièrement supprimées dans une version future. Si vous utilisez des clés RSA, vérifiez qu'elles ont au moins 3072 bits et que vos serveurs acceptent les signatures SHA-2. Pour les nouvelles clés, Ed25519 est le choix préféré.

Q: Cela affecte-t-il également SFTP et SCP ?

Oui. sftp et scp utilisent tous deux la même bibliothèque client SSH et sont soumis à la même application de sensibilité à la casse et suppression de DSA. Tout client SFTP (comme Cyberduck, Transmit ou FileZilla) utilisant le binaire SSH système sera également affecté. Les clients SFTP GUI qui intègrent leur propre bibliothèque SSH (comme Cyberduck avec sa propre construction libssh2) peuvent ne pas être affectés, mais cela dépend de l'application spécifique.

macOS Tahoe 26.3 a silencieusement modifié la gestion des noms d'utilisateur SSH pour les rendre sensibles à la casse et a désactivé les clés ssh-dss. Guide complet pour réparer les connexions SSH, mettre à jour les configurations et migrer vers les clés Ed25519.

Apple a publié macOS Tahoe 26.3 le 11 février 2026, et pour des milliers de développeurs et d'administrateurs système, les connexions SSH se sont immédiatement interrompues. Sans boîte de dialogue d'avertissement. Sans assistant de migration. Sans note de version l'indiquant. Un jour, vous pouviez utiliser ssh administrator@yourserver et le lendemain, vous receviez Connection closed by 10.10.83.28 port 22. Si vous dépendiez de clés DSA pour vous authentifier sur une infrastructure héritée, celles-ci ont cessé de fonctionner entièrement. Ce guide explique exactement ce qui a changé, pourquoi cela s'est produit et comment corriger chaque flux de travail affecté — des sessions interactives aux pipelines CI/CD automatisés.

Points Clés

macOS Tahoe 26.3 impose des noms d'utilisateur SSH sensibles à la casse. Saisir administrator au lieu de Administrator entraîne une fermeture immédiate de la connexion sans invite de mot de passe.
Les clés ssh-dss (DSA) ont été définitivement supprimées. OpenSSH 10.0, fourni avec Tahoe 26.3, a entièrement supprimé la prise en charge DSA lors de la compilation. Il n'existe aucun indicateur de configuration permettant de la réactiver.
Des avertissements d'échange de clés post-quantiques apparaissent désormais lors de la connexion à des serveurs qui ne prennent pas en charge mlkem768x25519-sha256 ou sntrup761x25519-sha512.
Ed25519 est le type de clé recommandé pour toutes les nouvelles clés SSH. Il est plus rapide, plus sécurisé et produit des signatures plus petites que RSA.
Chaque fichier ~/.ssh/config doit être audité pour détecter les incohérences de casse dans les directives User et toute référence à ssh-dss dans HostKeyAlgorithms ou PubkeyAcceptedAlgorithms.

Table des Matières

Ce qui a Exactement Changé dans SSH de macOS Tahoe 26.3
Diagnostic des Échecs de Connexion SSH après la Mise à Jour
Comprendre le Changement de Sensibilité à la Casse
Comprendre la Suppression des Clés DSA
Avertissements d'Échange de Clés Post-Quantiques
Correction Étape par Étape : Problèmes de Sensibilité à la Casse
Correction Étape par Étape : Migration de DSA vers Ed25519
Guide Complet d'Audit de Configuration SSH
Modifications de l'Agent SSH et Intégration du Keychain
Impact sur les Pipelines CI/CD et l'Automatisation
Impact sur les Flux de Travail de Développement à Distance
Solutions de Contournement pour l'Infrastructure Héritée
Meilleures Pratiques de Sécurité SSH pour 2026
Questions Fréquemment Posées
Conclusion

Ce qui a Exactement Changé dans SSH de macOS Tahoe 26.3

macOS Tahoe 26.3 est livré avec OpenSSH 10.0, qui introduit trois changements majeurs affectant les flux de travail SSH quotidiens. Apple n'a mis en évidence aucun de ces changements dans les notes de version destinées aux utilisateurs, laissant les développeurs les découvrir par des connexions échouées.

Changement 1 : Correspondance de Nom d'Utilisateur Sensible à la Casse

Avant Tahoe 26.3, le client SSH sur macOS était tolérant quant à la casse des noms d'utilisateur. Vous pouviez vous connecter avec ssh administrator@server, ssh Administrator@server ou même ssh ADMINISTRATOR@server, et le serveur distant résoudrait correctement le nom d'utilisateur tant que le système d'exploitation sous-jacent pouvait trouver le compte. Après la mise à jour, le client SSH applique une correspondance stricte de la casse avant même que la connexion soit entièrement établie. Si la casse ne correspond pas à ce qu'attend le serveur distant, la connexion est fermée immédiatement, avant que l'authentification par mot de passe ou l'échange de clés ne soit terminé.

Changement 2 : Suppression Complète de DSA (ssh-dss)

OpenSSH a progressivement abandonné DSA depuis la version 7.0 en 2015. Cette dépréciation a suivi une chronologie claire :

Date	Version OpenSSH	Statut DSA
2015	7.0	Désactivé par défaut, réactivable via config
2024	9.x	Optionnel à la compilation, activé par défaut
Mi-2024	9.x	Optionnel à la compilation, désactivé par défaut
Avril 2025	10.0	Supprimé entièrement du code source
Février 2026	10.0 (macOS Tahoe 26.3)	Distribué à tous les utilisateurs macOS

Avec macOS Tahoe 26.3, il n'existe plus de solution de contournement PubkeyAcceptedAlgorithms +ssh-dss. L'algorithme n'est pas présent dans le binaire. Toute configuration SSH faisant référence à ssh-dss produira une erreur Bad key types.

Changement 3 : Avertissements d'Échange de Clés Post-Quantiques

OpenSSH 10.0 a introduit un avertissement qui se déclenche lors de la connexion à des serveurs ne prenant pas en charge les algorithmes d'échange de clés post-quantiques. L'avertissement indique :

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

Bien qu'il s'agisse d'un avertissement et non d'un échec définitif, il crée du bruit dans la sortie du terminal et peut casser des scripts automatisés qui analysent la sortie SSH.

Ce qui N'a Pas Changé

Il convient de noter ce qui reste identique :

Les clés RSA continuent de fonctionner (avec les algorithmes de signature rsa-sha2-256 et rsa-sha2-512)
Les clés ECDSA continuent de fonctionner (bien qu'Ed25519 soit préféré)
La redirection de port SSH, le tunneling et ProxyJump fonctionnent de manière identique
Le format du fichier ~/.ssh/known_hosts n'a pas changé

Si vous êtes novice en SSH sur macOS ou si vous configurez un environnement de développement de zéro, notre guide de configuration développeur macOS Tahoe couvre la configuration initiale complète.

Diagnostic des Échecs de Connexion SSH après la Mise à Jour

Avant d'apporter des modifications, vous devez déterminer lequel des trois problèmes affecte vos connexions. La sortie détaillée SSH est votre principal outil de diagnostic.

Étape 1 : Activer la Sortie SSH Détaillée

Exécutez votre commande SSH échouée avec des indicateurs de triple verbosité pour voir la négociation complète du handshake :

ssh -vvv user@hostname

Cela produit une sortie détaillée montrant chaque étape de la connexion. Recherchez ces patterns spécifiques :

Pattern d'échec de sensibilité à la casse :

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

L'indicateur clé est que la connexion se ferme après l'établissement mais avant toute tentative d'authentification. Il n'y a pas de message "Permission denied" — la connexion tombe simplement.

Pattern d'échec de clé DSA :

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

ou :

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

Cette erreur apparaît immédiatement lorsque le client SSH analyse votre fichier de configuration, avant toute tentative de connexion.

Pattern d'avertissement post-quantique :

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

Cela apparaît pendant l'échange de clés mais n'empêche pas la connexion de se terminer.

Étape 2 : Vérifier la Version du Client SSH

Vérifiez quelle version d'OpenSSH est en cours d'exécution :

ssh -V

Sortie attendue sur macOS Tahoe 26.3 :

OpenSSH_10.0p1, LibreSSL 3.3.6

Si vous voyez une version plus ancienne, vous pouvez avoir un OpenSSH installé via Homebrew qui prend la priorité. Vérifiez quel binaire est utilisé :

which ssh

Le SSH système se trouve à /usr/bin/ssh. Si vous voyez /opt/homebrew/bin/ssh ou /usr/local/bin/ssh, vous utilisez une version Homebrew qui peut se comporter différemment.

Étape 3 : Tester avec des Paramètres Explicites

Isolez le problème en testant avec une casse de nom d'utilisateur et un type de clé explicites :

# Tester la sensibilité à la casse - essayer les deux cas
ssh -vvv Administrator@hostname
ssh -vvv administrator@hostname

# Tester sans interference du fichier de configuration
ssh -F /dev/null -vvv user@hostname

# Tester avec une clé spécifique
ssh -vvv -i ~/.ssh/id_ed25519 user@hostname

Sortie de Débogage SSH dans le Terminal

Étape 4 : Examiner la Configuration SSH pour les Erreurs

Analysez votre fichier de configuration pour identifier les lignes faisant référence aux algorithmes dépréciés :

# Vérifier les références ssh-dss
grep -n "ssh-dss" ~/.ssh/config

# Vérifier les références ssh-dss dans la configuration système
grep -n "ssh-dss" /etc/ssh/ssh_config

# Vérifier toutes les directives User pour révision de la casse
grep -n "User " ~/.ssh/config

Pour une compréhension plus approfondie de l'utilisation du Terminal sur macOS Tahoe, consultez notre guide Terminal macOS Tahoe.

Comprendre le Changement de Sensibilité à la Casse

Pourquoi ce Changement Interrompt les Connexions

Sur la plupart des systèmes de type Unix, les noms d'utilisateur sont sensibles à la casse au niveau du système d'exploitation. Un utilisateur nommé Administrator est techniquement un compte différent de administrator. Cependant, le protocole SSH lui-même (RFC 4252) indique que les noms d'utilisateur sont "sensibles à la casse" mais reconnaît que les implémentations de serveur peuvent choisir de gérer cela différemment.

Avant macOS Tahoe 26.3, le client SSH de macOS était tolérant. Lorsque vous tapiez ssh administrator@server, le client envoyait le nom d'utilisateur tel quel, et de nombreux serveurs SSH (en particulier ceux exécutés sur Windows, macOS ou les appliances réseau) normalisaient la casse lors de l'authentification. La connexion réussissait parce que le serveur effectuait le travail de mise en correspondance de administrator avec le compte Administrator.

Avec OpenSSH 10.0, le client SSH sur macOS effectue désormais une vérification pré-authentification plus stricte. Si le serveur renvoie un message de protocole précoce indiquant une inadéquation de casse, la connexion est terminée avant que l'authentification ne procède. Cela signifie :

Les connexions aux serveurs Windows (qui normalisaient historiquement la casse) peuvent être interrompues
Les connexions aux appliances réseau (routeurs, commutateurs, périphériques NAS) qui utilisent des noms d'utilisateur insensibles à la casse peuvent être interrompues
Les connexions aux serveurs macOS où le compte administrateur est Administrator (A majuscule) mais les scripts utilisent administrator (a minuscule) seront interrompues
Les connexions aux serveurs Linux sont moins susceptibles d'être affectées car les noms d'utilisateur Linux sont déjà sensibles à la casse

Scénarios Courants qui se Rompent

Scénario 1 : Gestion à Distance macOS vers macOS

De nombreux administrateurs système se connectent aux Mac distants avec :

ssh [email protected]

Mais le compte administrateur macOS par défaut est créé comme Administrator avec un A majuscule. Cela fonctionnait avant Tahoe 26.3 et échoue après.

Scénario 2 : Gestion des Appliances Réseau

La connexion aux routeurs, commutateurs, pare-feux et périphériques NAS utilise souvent des noms d'utilisateur génériques :

ssh [email protected]
ssh [email protected]

Si le périphérique stocke le nom d'utilisateur comme Admin ou ROOT, ces connexions échoueront maintenant silencieusement.

Scénario 3 : Alias de Configuration SSH

De nombreux développeurs ont des entrées de configuration SSH avec une casse incorrecte qui fonctionnaient auparavant :

# ~/.ssh/config - ceci peut maintenant être rompu
Host production
    HostName prod.example.com
    User deploy      # Le serveur attend "Deploy"
    IdentityFile ~/.ssh/prod_key

Comprendre la Suppression des Clés DSA

L'Argument de Sécurité Contre DSA

DSA (Digital Signature Algorithm) tel qu'implémenté dans SSH utilise une longueur de clé fixe de 1024 bits et SHA-1 pour le hachage. Cette combinaison fournit environ 80 bits de sécurité symétrique, bien en dessous du minimum de 128 bits recommandé par les normes de sécurité modernes.

Les faiblesses spécifiques des clés DSA :

Propriété	DSA (ssh-dss)	Ed25519	RSA-4096
Taille de clé	1024 bits	256 bits	4096 bits
Algorithme de hachage	SHA-1	SHA-512	SHA-256/512
Niveau de sécurité	~80 bits	~128 bits	~128 bits
Taille de signature	40 octets	64 octets	512 octets
Vitesse de signature	Lente	Rapide	Modérée
Vitesse de vérification	Lente	Rapide	Modérée
Vulnérabilité aux biais	Élevée	Aucune	Aucune

DSA est particulièrement vulnérable aux failles d'implémentation. Si le générateur de nombres aléatoires utilisé lors de la signature présente un biais, la clé privée peut être récupérée à partir d'un petit nombre de signatures. Cela a été exploité dans des attaques réelles.

Ce que "Supprimé" Signifie Réellement

Dans les versions précédentes de macOS, DSA était désactivé par défaut mais pouvait être réactivé avec des options de configuration :

# Cela fonctionnait sur macOS Sequoia et versions antérieures
Host legacy-server
    HostKeyAlgorithms +ssh-dss
    PubkeyAcceptedAlgorithms +ssh-dss

Dans macOS Tahoe 26.3, ces lignes de configuration elles-mêmes provoquent des erreurs car le binaire SSH ne reconnaît plus ssh-dss comme un identifiant d'algorithme valide. L'erreur est :

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

Cela signifie :

Vous ne pouvez pas utiliser de clés DSA pour l'authentification (connexion par clé publique)
Vous ne pouvez pas accepter les clés hôte DSA des serveurs
Vous ne pouvez même pas référencer ssh-dss dans vos fichiers de configuration sans provoquer des erreurs
L'outil ssh-keygen ne peut plus générer de clés DSA

Vérifier si vous avez des Clés DSA

Avant de procéder à la migration, vérifiez vos clés existantes :

# Lister toutes les clés SSH avec leurs types
for key in ~/.ssh/*.pub; do
    echo "=== $key ==="
    ssh-keygen -l -f "$key"
done

Exemple de sortie :

=== /Users/you/.ssh/id_dsa.pub ===
1024 SHA256:abc123... you@mac (DSA)          # Cette clé doit être remplacée
=== /Users/you/.ssh/id_ed25519.pub ===
256 SHA256:xyz789... you@mac (ED25519)       # Cette clé est correcte
=== /Users/you/.ssh/id_rsa.pub ===
3072 SHA256:def456... you@mac (RSA)          # Cette clé est correcte

Toute clé identifiée comme (DSA) doit être remplacée. Si vous en trouvez une, ne la supprimez pas encore — vous en avez besoin pour identifier quels serveurs l'ont autorisée.

Avertissements d'Échange de Clés Post-Quantiques

Ce que Signifie l'Avertissement

OpenSSH 10.0 a introduit l'échange de clés post-quantiques utilisant l'algorithme ML-KEM (anciennement CRYSTALS-Kyber) hybridé avec X25519. L'algorithme d'échange de clés par défaut est maintenant mlkem768x25519-sha256, avec sntrup761x25519-sha512 comme repli.

Lors de la connexion à un serveur qui ne prend en charge aucun de ces algorithmes, OpenSSH affiche :

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

Une attaque "stocker maintenant, déchiffrer plus tard" signifie qu'un adversaire pourrait enregistrer votre trafic SSH chiffré aujourd'hui et le déchiffrer dans le futur lorsque les ordinateurs quantiques seront capables de casser les algorithmes classiques d'échange de clés.

Quand vous Verrez cet Avertissement

Lors de la connexion à des serveurs exécutant OpenSSH 8.x ou antérieur
Lors de la connexion à des appliances réseau avec des implémentations SSH intégrées
Lors de la connexion à des instances cloud avec des versions plus anciennes du démon SSH
Lors de la connexion à GitHub, GitLab ou Bitbucket (peut ou non prendre en charge les algorithmes PQ)

Réduire au Silence l'Avertissement

Si vous comprenez le risque et souhaitez supprimer l'avertissement, ajoutez ceci à votre ~/.ssh/config :

# Supprimer les avertissements post-quantiques globalement
Host *
    WarnWeakCrypto no

Ou uniquement pour des hôtes spécifiques :

Host legacy-server
    HostName 192.168.1.100
    WarnWeakCrypto no

La solution idéale est de mettre à jour vos serveurs vers OpenSSH 9.0 ou ultérieur, qui prend en charge sntrup761x25519-sha512, ou OpenSSH 9.9+, qui prend en charge le plus récent mlkem768x25519-sha256.

Correction Étape par Étape : Problèmes de Sensibilité à la Casse

Correction 1 : Déterminer la Casse Correcte du Nom d'Utilisateur

Vérifiez d'abord le nom d'utilisateur exact sur le système distant. La méthode dépend du système d'exploitation distant :

Pour les serveurs Linux/macOS distants :

# Si vous pouvez encore vous connecter via la console, l'accès physique ou un autre client SSH
grep "your_username" /etc/passwd

# Ou utiliser la commande id
id

# Exemple de sortie : uid=501(Administrator) gid=20(staff) groups=...

Pour les serveurs Windows distants (OpenSSH) :

# Dans PowerShell sur la machine distante
whoami
# Sortie : DOMAIN\Administrator

Pour les appliances réseau :

Consultez l'interface de gestion web du périphérique ou la documentation pour le format exact du nom d'utilisateur. Patterns courants :

Cisco IOS : généralement en minuscules (admin)
Juniper : généralement en minuscules (root)
Synology NAS : sensible à la casse telle que créée
QNAP NAS : sensible à la casse telle que créée

Correction 2 : Mettre à Jour votre Fichier de Configuration SSH

Ouvrez votre configuration SSH et corrigez toutes les directives User :

# Ouvrir le fichier de configuration
nano ~/.ssh/config

Avant (cassé) :

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

Host nas
    HostName nas.local
    User admin
    Port 22

Après (corrigé) :

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

Host nas
    HostName nas.local
    User Admin
    Port 22

Correction 3 : Mettre à Jour les Alias Shell et les Scripts

Recherchez les commandes SSH dans votre configuration shell :

# Vérifier les alias bash
grep -n "ssh " ~/.bashrc ~/.bash_profile 2>/dev/null

# Vérifier les alias zsh
grep -n "ssh " ~/.zshrc ~/.zprofile 2>/dev/null

# Vérifier les commandes SSH dans les scripts personnalisés
grep -rn "ssh " ~/scripts/ ~/bin/ 2>/dev/null

Mettez à jour tous les noms d'utilisateur codés en dur pour utiliser la casse correcte.

Correction 4 : Mettre à Jour les Variables d'Environnement

Certains outils utilisent des variables d'environnement pour les noms d'utilisateur SSH :

# Vérifier les variables d'environnement liées à SSH
env | grep -i ssh
env | grep -i user

# Variables courantes à vérifier
echo $DEPLOY_USER
echo $SSH_USER
echo $REMOTE_USER

Correction 5 : Vérifier la Correction

Après avoir apporté des modifications, vérifiez chaque connexion :

# Tester avec une sortie détaillée
ssh -v production

# Attendu : authentification réussie
# debug1: Authentication succeeded (publickey).

Correction Étape par Étape : Migration de DSA vers Ed25519

Cette section décrit le processus complet de remplacement des clés DSA par des clés Ed25519. Si vous avez besoin d'un aperçu des commandes Terminal, notre guide de maîtrise du Terminal Mac couvre tous les fondamentaux.

Flux de Migration des Clés SSH

Phase 1 : Inventorier vos Clés DSA

Avant de générer de nouvelles clés, documentez où vos clés DSA sont utilisées :

# Étape 1 : Trouver toutes les clés DSA sur votre système
find ~/.ssh -name "*.pub" -exec grep -l "ssh-dss" {} \;

# Étape 2 : Pour chaque clé DSA, vérifier quels serveurs l'autorisent
# Notez l'empreinte de la clé publique
ssh-keygen -l -f ~/.ssh/id_dsa.pub

# Étape 3 : Vérifier les clés hôte DSA dans known_hosts
grep "ssh-dss" ~/.ssh/known_hosts | awk '{print $1}'

Créez une liste de contrôle de migration :

# Créer un fichier de suivi de migration
cat > ~/ssh_migration_checklist.txt << 'EOF'
Liste de Contrôle de Migration de Clé DSA SSH
===============================
Date : $(date)

Clés DSA Trouvées :
- [ ] ~/.ssh/id_dsa -> Utilisée pour : _______________
- [ ] ~/.ssh/id_dsa.pub -> Autorisée sur : _______________

Serveurs avec Clés Hôte DSA :
- [ ] server1.example.com
- [ ] 192.168.1.100

Automatisation/Scripts Utilisant DSA :
- [ ] deploy.sh
- [ ] backup-cron.sh
- [ ] Pipeline CI/CD : _______________
EOF

Phase 2 : Générer de Nouvelles Clés Ed25519

Générez une nouvelle paire de clés Ed25519 avec un commentaire significatif :

# Générer une clé Ed25519 avec un commentaire descriptif
ssh-keygen -t ed25519 -C "yourname@macbook-2026-02" -f ~/.ssh/id_ed25519

# Il vous sera demandé une phrase de passe - UTILISEZ-EN UNE
# Une phrase de passe protège votre clé privée si votre machine est compromise

Si vous avez besoin de clés séparées pour différents usages (recommandé pour l'isolement de sécurité) :

# Clé pour les serveurs professionnels
ssh-keygen -t ed25519 -C "work-servers-2026" -f ~/.ssh/id_ed25519_work

# Clé pour les projets personnels
ssh-keygen -t ed25519 -C "personal-2026" -f ~/.ssh/id_ed25519_personal

# Clé pour l'automatisation CI/CD
ssh-keygen -t ed25519 -C "cicd-automation-2026" -f ~/.ssh/id_ed25519_cicd

Vérifiez les clés générées :

# Vérifier la nouvelle clé
ssh-keygen -l -f ~/.ssh/id_ed25519.pub

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

Phase 3 : Déployer les Nouvelles Clés sur les Serveurs

Pour chaque serveur qui utilisait précédemment votre clé DSA, déployez la nouvelle clé publique Ed25519 :

Méthode 1 : Utiliser ssh-copy-id (si vous pouvez encore vous authentifier)

Si vous avez une autre méthode d'authentification fonctionnelle (mot de passe, clé différente) :

# Déployer la nouvelle clé en utilisant l'authentification par mot de passe
ssh-copy-id -i ~/.ssh/id_ed25519.pub user@server

# Ou spécifier une clé fonctionnelle pour l'authentification lors du déploiement
ssh-copy-id -i ~/.ssh/id_ed25519.pub -o "IdentityFile=~/.ssh/id_rsa" user@server

Méthode 2 : Déploiement manuel (si ssh-copy-id n'est pas disponible)

# Copier le contenu de la clé publique
cat ~/.ssh/id_ed25519.pub | pbcopy

# Se connecter en SSH au serveur en utilisant n'importe quelle méthode fonctionnelle
ssh user@server

# Sur le serveur distant, ajouter la clé
mkdir -p ~/.ssh
chmod 700 ~/.ssh
echo "COLLER_VOTRE_CLÉ_PUBLIQUE_ICI" >> ~/.ssh/authorized_keys
chmod 600 ~/.ssh/authorized_keys

Méthode 3 : Pour les serveurs auxquels vous ne pouvez pas accéder en SSH

Si la clé DSA était votre seule méthode d'authentification et ne fonctionne plus :

Utilisez la console de gestion web du serveur (si disponible)
Accédez via console physique ou IPMI/iLO/iDRAC
Utilisez un hôte de rebond qui a encore accès
Contactez l'administrateur du serveur

Phase 4 : Mettre à Jour la Configuration SSH

Remplacez les références aux clés DSA dans votre configuration SSH :

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

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

Phase 5 : Nettoyer les Hôtes Connus

Supprimez les entrées de clés hôte DSA obsolètes :

# Trouver les serveurs avec des clés hôte DSA dans known_hosts
grep "ssh-dss" ~/.ssh/known_hosts

# Supprimer des entrées d'hôte spécifiques (la clé hôte sera ré-acceptée lors de la prochaine connexion)
ssh-keygen -R hostname_or_ip

# Ou supprimer toutes les entrées DSA d'un coup
# Sauvegarder d'abord le fichier
cp ~/.ssh/known_hosts ~/.ssh/known_hosts.backup.$(date +%Y%m%d)

# Ensuite supprimer les entrées DSA
grep -v "ssh-dss" ~/.ssh/known_hosts > ~/.ssh/known_hosts.tmp
mv ~/.ssh/known_hosts.tmp ~/.ssh/known_hosts

Phase 6 : Vérifier que Tout Fonctionne

Testez chaque connexion au serveur :

# Tester les connexions avec sortie détaillée
ssh -v old-server

# Vérifier que la bonne clé est proposée
# Rechercher : debug1: Offering public key: /Users/you/.ssh/id_ed25519_work ED25519

# Exécuter un test de connectivité complet pour tous les hôtes configurés
for host in $(grep "^Host " ~/.ssh/config | awk '{print $2}' | grep -v '\*'); do
    echo "Test : $host"
    ssh -o ConnectTimeout=5 -o BatchMode=yes "$host" echo "OK" 2>&1
    echo "---"
done

Phase 7 : Retirer la Clé DSA

Une fois que tous les serveurs sont migrés et vérifiés :

# Archiver les anciennes clés DSA (ne pas supprimer immédiatement)
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.*

Conservez les clés archivées pendant au moins 90 jours au cas où vous découvririez un serveur manqué.

Guide Complet d'Audit de Configuration SSH

Après avoir traité les problèmes individuels, effectuez un audit complet de votre configuration SSH. C'est particulièrement important si vous utilisez SSH sur macOS depuis des années et avez accumulé des entrées de configuration sur plusieurs mises à niveau de macOS.

Audit Étape 1 : Vérifier les Algorithmes Dépréciés

# Vérifier les références à des algorithmes dépréciés
echo "=== Vérification de ~/.ssh/config ==="
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 "=== Vérification de /etc/ssh/ssh_config ==="
grep -n -E "(ssh-dss|ssh-dsa|diffie-hellman-group1-sha1)" /etc/ssh/ssh_config 2>/dev/null

echo ""
echo "=== Vérification de /etc/ssh/ssh_config.d/ ==="
grep -rn -E "(ssh-dss|ssh-dsa)" /etc/ssh/ssh_config.d/ 2>/dev/null

Audit Étape 2 : Valider la Syntaxe de Configuration

# Tester la syntaxe de configuration SSH sans se connecter
ssh -G test-host 2>&1 | head -5

# En cas d'erreurs, elles apparaîtront comme :
# /Users/you/.ssh/config line X: Bad key types '...'

Audit Étape 3 : Examiner Toutes les Directives User

# Extraire toutes les directives User et les hôtes auxquels elles s'appliquent
awk '/^Host /{host=$2} /User /{print host, $0}' ~/.ssh/config

Examinez la sortie et vérifiez la casse de chaque nom d'utilisateur.

Audit Étape 4 : Vérifier les Permissions de Fichiers

SSH est strict sur les permissions de fichiers. Des permissions incorrectes peuvent provoquer des échecs silencieux :

# Vérifier et corriger les permissions du répertoire SSH
echo "=== Permissions du répertoire ==="
ls -la ~/.ssh/

echo ""
echo "=== Permissions attendues ==="
echo "~/.ssh/           -> drwx------ (700)"
echo "~/.ssh/config     -> -rw------- (600)"
echo "~/.ssh/id_*       -> -rw------- (600) pour les clés privées"
echo "~/.ssh/*.pub      -> -rw-r--r-- (644) pour les clés publiques"
echo "~/.ssh/authorized_keys -> -rw------- (600)"
echo "~/.ssh/known_hosts     -> -rw-r--r-- (644)"

# Corriger les permissions si nécessaire
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 Étape 5 : Modèle de Configuration SSH Moderne Recommandé

Voici un modèle de configuration SSH moderne et complet qui fonctionne avec macOS Tahoe 26.3 :

# ~/.ssh/config
# Mis à jour pour macOS Tahoe 26.3 / OpenSSH 10.0
# Dernier audit : 2026-02-28

# ============================================
# Valeurs par défaut globales
# ============================================
Host *
    # Utiliser les clés Ed25519 par défaut
    IdentityFile ~/.ssh/id_ed25519

    # Ne proposer que les clés explicitement configurées pour chaque hôte
    IdentitiesOnly yes

    # Intégration macOS Keychain
    UseKeychain yes
    AddKeysToAgent yes

    # Préférences d'échange de clés modernes
    KexAlgorithms mlkem768x25519-sha256,[email protected],curve25519-sha256,[email protected]

    # Stabilité de connexion
    ServerAliveInterval 60
    ServerAliveCountMax 3

    # Renforcement de la sécurité
    HashKnownHosts yes
    StrictHostKeyChecking ask

# ============================================
# Serveurs professionnels
# ============================================
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

# ============================================
# Serveurs personnels
# ============================================
Host homelab
    HostName 192.168.1.100
    User admin
    IdentityFile ~/.ssh/id_ed25519_personal

# ============================================
# Configuration de l'hôte de rebond
# ============================================
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

Modifications de l'Agent SSH et Intégration du Keychain

macOS Tahoe 26.3 apporte également des modifications subtiles à la façon dont l'agent SSH interagit avec le Keychain macOS.

Intégration du Keychain

La directive UseKeychain spécifique à macOS continue de fonctionner dans Tahoe 26.3, mais son comportement a été affiné :

# Ajouter votre nouvelle clé Ed25519 au Keychain macOS
ssh-add --apple-use-keychain ~/.ssh/id_ed25519

# Vérifier que la clé a été ajoutée
ssh-add -l

Si la clé a été ajoutée avec succès, vous verrez :

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

Chargement Persistant des Clés

Assurez-vous que votre configuration SSH inclut ces directives pour maintenir la persistance des clés entre les redémarrages :

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

Sans UseKeychain yes, vous devrez exécuter ssh-add après chaque redémarrage.

Vérification de l'Agent SSH

# Vérifier si l'agent est en cours d'exécution
echo $SSH_AUTH_SOCK

# Lister les clés chargées
ssh-add -l

# Si aucune clé n'est chargée, les ajouter
ssh-add --apple-use-keychain ~/.ssh/id_ed25519

Pour plus de détails sur les configurations de sécurité macOS, consultez notre guide de sécurité et confidentialité macOS Tahoe.

Impact sur les Pipelines CI/CD et l'Automatisation

Les changements SSH dans macOS Tahoe 26.3 ont des implications significatives pour les flux de travail automatisés. Si votre pipeline CI/CD s'exécute sur des runners macOS (GitHub Actions, GitLab CI, Jenkins sur Mac), ces changements vous affecteront après la mise à niveau du système d'exploitation du runner.

GitHub Actions

Si vous utilisez des runners macos-latest ou macos-15, le binaire SSH sera éventuellement mis à jour. Auditez vos workflows maintenant :

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

# APRÈS (corrigé)
- name: Deploy
  run: |
    ssh Administrator@${{ secrets.DEPLOY_HOST }} "cd /app && git pull"

Vérifiez vos secrets de déploiement :

DEPLOY_USER : vérifiez que la casse correspond au compte distant
SSH_PRIVATE_KEY : vérifiez qu'il ne s'agit pas d'une clé DSA
KNOWN_HOSTS : vérifiez qu'il n'y a pas d'entrées de clé hôte DSA

GitLab CI

# .gitlab-ci.yml
deploy:
  before_script:
    # Vérifier le type de clé avant le déploiement
    - ssh-keygen -l -f ~/.ssh/id_deploy
    # S'assurer que ce n'est PAS DSA
    - |
      if ssh-keygen -l -f ~/.ssh/id_deploy | grep -q "DSA"; then
        echo "ERREUR : Clé DSA détectée. Migration requise."
        exit 1
      fi
  script:
    # Utiliser la casse correcte pour le nom d'utilisateur
    - ssh -o StrictHostKeyChecking=no Deploy@$DEPLOY_HOST "deploy.sh"

Jenkins

Pour les pipelines Jenkins s'exécutant sur des agents macOS :

pipeline {
    agent { label 'macos' }
    stages {
        stage('Pre-flight SSH Check') {
            steps {
                sh '''
                    # Vérifier la version SSH
                    ssh -V

                    # Vérifier les clés DSA dans les credentials
                    for key in ~/.ssh/*.pub; do
                        if ssh-keygen -l -f "$key" | grep -q "DSA"; then
                            echo "AVERTISSEMENT : Clé DSA trouvée : $key"
                            exit 1
                        fi
                    done

                    echo "Vérification pré-déploiement SSH réussie"
                '''
            }
        }
    }
}

Ansible Playbooks

Si vous exécutez Ansible depuis un nœud de contrôle macOS :

# ansible.cfg
[defaults]
# S'assurer du bon binaire SSH
ssh_executable = /usr/bin/ssh

# Forcer des arguments SSH spécifiques
[ssh_connection]
ssh_args = -o IdentitiesOnly=yes -o IdentityFile=~/.ssh/id_ed25519_ansible

Vérifiez la casse des noms d'utilisateur dans votre inventaire Ansible :

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

# APRÈS
[webservers]
web1.example.com ansible_user=Administrator

Scripts de Sauvegarde Automatisés

Examinez toutes les tâches cron ou tâches launchd qui utilisent SSH :

# Trouver toutes les tâches cron avec des références SSH
crontab -l 2>/dev/null | grep -i ssh

# Trouver les plists launchd avec des références SSH
grep -rl "ssh" ~/Library/LaunchAgents/ /Library/LaunchAgents/ /Library/LaunchDaemons/ 2>/dev/null

# Vérifier les scripts de sauvegarde rsync (rsync utilise SSH par défaut)
grep -rn "rsync.*@" ~/scripts/ ~/bin/ 2>/dev/null

Impact sur les Flux de Travail de Développement à Distance

VS Code Remote SSH

L'extension Remote SSH de Visual Studio Code stocke des configurations de connexion qui peuvent être affectées :

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

# Vérifier les références de configuration SSH VS Code
grep -n "ssh" ~/Library/Application\ Support/Code/User/settings.json 2>/dev/null

Mettez à jour vos cibles SSH VS Code pour utiliser la casse correcte du nom d'utilisateur et des clés non-DSA.

JetBrains Gateway / Développement à Distance

Les IDEs JetBrains stockent les configurations SSH séparément :

# Vérifier les configurations SSH JetBrains
find ~/Library/Application\ Support/JetBrains -name "*.xml" -exec grep -l "ssh" {} \; 2>/dev/null

tmux et Sessions Persistantes

Si vous utilisez tmux ou screen via SSH, vos scripts de reconnexion doivent être mis à jour :

# Alias de reconnexion tmux courant - vérifier la casse du nom d'utilisateur
alias tm='ssh -t Administrator@server "tmux attach || tmux new"'

Pour une configuration complète de l'environnement développeur, consultez notre guide ultime du développeur macOS Tahoe.

Solutions de Contournement pour l'Infrastructure Héritée

Certains environnements ne peuvent pas être mis à jour immédiatement. Les appliances réseau, les systèmes embarqués et les serveurs hérités peuvent nécessiter DSA pendant des années. Voici des solutions pratiques, classées de la plus à la moins recommandée.

Solution 1 : Utiliser un Hôte de Rebond (Recommandé)

Configurez un hôte bastion Linux qui prend encore en charge DSA et utilisez-le comme proxy :

# ~/.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

L'hôte bastion exécute un OpenSSH plus ancien (ou un compilé avec le support DSA) et gère la négociation DSA avec le périphérique hérité. Votre Mac n'a besoin que de s'authentifier auprès du bastion en utilisant Ed25519.

Solution 2 : Utiliser un Conteneur Docker

Exécutez un client OpenSSH plus ancien à l'intérieur d'un conteneur Docker :

# Créer un Dockerfile pour SSH hérité
cat > ~/legacy-ssh/Dockerfile << 'EOF'
FROM alpine:3.18
RUN apk add --no-cache openssh-client
ENTRYPOINT ["ssh"]
EOF

# Le construire
docker build -t legacy-ssh ~/legacy-ssh/

# L'utiliser pour se connecter aux périphériques hérités
docker run --rm -it \
    -v ~/.ssh:/root/.ssh:ro \
    legacy-ssh \
    -o HostKeyAlgorithms=+ssh-dss \
    -o PubkeyAcceptedKeyTypes=+ssh-dss \
    admin@legacy-device

Créez un alias shell pour plus de commodité :

# Ajouter à ~/.zshrc
alias legacy-ssh='docker run --rm -it -v ~/.ssh:/root/.ssh:ro legacy-ssh'

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

Solution 3 : Installer un OpenSSH Plus Ancien via Homebrew

Vous pouvez compiler OpenSSH 9.7p1 (la dernière version avec prise en charge DSA) à partir des sources :

# Installer les dépendances
brew install openssl@3

# Télécharger le source d'OpenSSH 9.7p1
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

# Configurer avec support DSA et préfixe personnalisé
./configure \
    --prefix=$HOME/openssh97 \
    --with-ssl-dir=$(brew --prefix openssl@3)

# Compiler et installer
make -j$(sysctl -n hw.ncpu)
make install

# Utiliser l'ancien binaire SSH
~/openssh97/bin/ssh -o HostKeyAlgorithms=+ssh-dss admin@legacy-device

Créez un alias pour les connexions héritées :

# Ajouter à ~/.zshrc
alias ssh-legacy='~/openssh97/bin/ssh -o HostKeyAlgorithms=+ssh-dss -o PubkeyAcceptedKeyTypes=+ssh-dss'

# Utilisation
ssh-legacy admin@old-router

Solution 4 : Utiliser une Machine Virtuelle Linux

Si vous utilisez UTM, Parallels ou VMware Fusion :

Configurez une VM Linux légère (Alpine ou Ubuntu Server)
Connectez-vous en SSH de votre Mac à la VM (en utilisant Ed25519)
Depuis la VM, connectez-vous en SSH au périphérique hérité (en utilisant DSA)

Cela fournit une isolation complète et ne nécessite pas de modifier votre installation SSH macOS.

À Long Terme : Planifier le Remplacement des Équipements

Si vous dépendez de DSA parce que vos appliances réseau ne prennent pas en charge les algorithmes modernes, c'est un signal clair que ces équipements ont atteint leur fin de vie d'un point de vue sécurité. Planifiez un calendrier de remplacement :

Routeurs/Commutateurs : La plupart des fournisseurs d'entreprise prennent en charge Ed25519 depuis 2018
Périphériques NAS : Synology, QNAP et TrueNAS prennent tous en charge Ed25519
Serveurs hérités : Si vous exécutez OpenSSH antérieur à 6.5, tout le système doit être mis à jour

Meilleures Pratiques de Sécurité SSH pour 2026

Avec les changements de macOS Tahoe 26.3 comme catalyseur, c'est le bon moment pour mettre en œuvre des améliorations complètes de la sécurité SSH.

Meilleures Pratiques de Gestion des Clés

1. Utiliser des clés séparées pour des rôles séparés :

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

# Projets personnels
ssh-keygen -t ed25519 -f ~/.ssh/id_ed25519_personal -C "personal-2026"

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

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

2. Toujours utiliser une phrase de passe :

Une phrase de passe chiffre votre clé privée au repos. Si votre machine est compromise, l'attaquant ne peut pas utiliser vos clés SSH sans la phrase de passe. Combinée à l'intégration macOS Keychain, vous n'avez besoin de saisir la phrase de passe qu'une seule fois.

# Lorsqu'invité lors de la génération de clé :
Enter passphrase (empty for no passphrase): [entrez une phrase de passe robuste]
Enter same passphrase again: [confirmer]

3. Faire pivoter les clés annuellement :

Incluez l'année dans les commentaires de votre clé pour savoir quand elles ont été générées :

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

Quand l'année change, générez de nouvelles clés, déployez-les et retirez les anciennes.

4. Définir les bonnes permissions de fichiers :

# Clés privées : lecture seule par le propriétaire
chmod 400 ~/.ssh/id_ed25519*
chmod 600 ~/.ssh/id_ed25519*.pub

# En fait, les clés publiques peuvent être lisibles par tous
chmod 644 ~/.ssh/id_ed25519*.pub

# Le répertoire SSH lui-même
chmod 700 ~/.ssh

# Fichier de configuration
chmod 600 ~/.ssh/config

Renforcement Côté Serveur

Si vous gérez des serveurs SSH, profitez de cette occasion pour les renforcer :

# /etc/ssh/sshd_config paramètres recommandés

# Désactiver l'authentification par mot de passe (utiliser uniquement les clés)
PasswordAuthentication no

# Désactiver la connexion root
PermitRootLogin no

# N'autoriser que des utilisateurs spécifiques
AllowUsers deploy admin

# Utiliser un échange de clés moderne
KexAlgorithms mlkem768x25519-sha256,[email protected],curve25519-sha256

# Utiliser des algorithmes de clé hôte modernes
HostKeyAlgorithms ssh-ed25519,rsa-sha2-512,rsa-sha2-256

# Utiliser des chiffrements modernes
Ciphers [email protected],[email protected],[email protected]

# Utiliser des MACs modernes
MACs [email protected],[email protected]

# Limitation du débit
MaxAuthTries 3
MaxSessions 5
LoginGraceTime 30

Après avoir modifié sshd_config, testez toujours avant de vous déconnecter :

# Valider la configuration
sudo sshd -t

# Si pas d'erreur, redémarrer sshd
sudo systemctl restart sshd

# IMPORTANT : Gardez votre session actuelle ouverte et testez avec une NOUVELLE connexion
# avant de fermer celle existante

Surveillance et Alertes

Configurez la surveillance des événements d'authentification SSH :

# Surveiller auth.log pour les tentatives échouées (serveurs Linux)
tail -f /var/log/auth.log | grep "sshd"

# Surveiller le journal système macOS pour les événements SSH
log stream --predicate 'process == "sshd"' --level info

Résolution des Erreurs Courantes

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

Cause : Inadéquation de casse du nom d'utilisateur.

Correction :

# Déterminer le nom d'utilisateur correct
ssh -vvv user@host 2>&1 | grep "debug1: Sending"

# Essayer la casse opposée
ssh Administrator@host  # si 'administrator' a échoué
ssh administrator@host  # si 'Administrator' a échoué

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

Cause : La configuration SSH fait référence à l'algorithme DSA supprimé.

Correction :

# Trouver et modifier la ligne problématique
grep -n "ssh-dss" ~/.ssh/config

# Supprimer ou remplacer la référence à l'algorithme
# Avant : HostKeyAlgorithms +ssh-dss
# Après :  (supprimer la ligne entière, ou remplacer par des algorithmes modernes)

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

Cause : La configuration SSH a une liste d'algorithmes composée incluant DSA.

Correction :

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

# Après (supprimer ssh-dss, garder ssh-rsa si nécessaire pour RSA hérité)
HostKeyAlgorithms +ssh-rsa
PubkeyAcceptedAlgorithms +ssh-rsa

Note : ssh-rsa (avec signatures SHA-1) est également déprécié. Utilisez rsa-sha2-256 ou rsa-sha2-512 si vous devez utiliser RSA :

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

Erreur : "No matching host key type found"

Cause : Le serveur distant ne propose que des clés hôte DSA.

Correction : Cela nécessite une action côté serveur. Générez de nouvelles clés hôte sur le serveur :

# Sur le serveur distant (si vous avez accès à la console)
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

Si vous ne pouvez pas mettre à jour le serveur, utilisez les solutions de contournement avec hôte de rebond ou Docker décrites ci-dessus.

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

Cause : Le serveur distant ne prend pas en charge l'échange de clés post-quantique.

Correction :

# Supprimer pour un hôte spécifique
# Ajouter à ~/.ssh/config :
Host old-server
    WarnWeakCrypto no

# Ou supprimer globalement (non recommandé)
Host *
    WarnWeakCrypto no

Erreur : "Permission denied (publickey)"

Cause : Après la migration de clé, la nouvelle clé n'est pas autorisée sur le serveur.

Correction :

# Vérifier quelle clé est proposée
ssh -v user@host 2>&1 | grep "Offering public key"

# Déployer la bonne clé
ssh-copy-id -i ~/.ssh/id_ed25519.pub user@host

Erreur : "WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED"

Cause : Après avoir supprimé les entrées de clé hôte DSA de known_hosts, le serveur propose un type de clé hôte différent.

Correction :

# Supprimer l'ancienne entrée de clé hôte
ssh-keygen -R hostname

# Se reconnecter et accepter la nouvelle clé hôte
ssh user@hostname
# Il vous sera demandé de vérifier la nouvelle empreinte de clé hôte

Comprendre le Contexte Plus Large

Les changements SSH dans macOS Tahoe 26.3 font partie d'une tendance plus large dans l'industrie. Comprendre ce contexte vous aide à vous préparer aux changements futurs plutôt qu'à réagir à chacun d'eux.

Chronologie des Versions OpenSSH

Version	Date	Changements Clés
7.0	2015	DSA désactivé par défaut
8.2	2020	Signatures SHA-1 pour RSA dépréciées
8.8	2022	Signatures SHA-1 RSA désactivées par défaut
9.0	2022	KEx post-quantique (sntrup761) activé par défaut
9.9	2024	Support post-quantique ML-KEM ajouté
10.0	2025	DSA entièrement supprimé, ML-KEM par défaut

macOS a historiquement pris 6 à 12 mois de retard sur ces versions, c'est pourquoi la suppression de DSA affecte les utilisateurs macOS début 2026 malgré qu'elle soit dans OpenSSH 10.0 depuis avril 2025.

Ce à quoi s'Attendre Ensuite

D'après la feuille de route de développement OpenSSH :

Les signatures SHA-1 RSA (ssh-rsa) seront probablement entièrement supprimées dans OpenSSH 11.x
ECDSA avec courbes NIST pourrait être déprécié en faveur d'Ed25519
Les signatures post-quantiques (pas seulement l'échange de clés) seront ajoutées
L'authentification basée sur des certificats sera de plus en plus promue par rapport aux clés publiques brutes

Préparez-vous maintenant en :

Vous assurant que toutes vos clés sont Ed25519
Passant à rsa-sha2-256/512 si vous devez utiliser RSA
Testant l'échange de clés post-quantique avec vos serveurs
Évaluant l'infrastructure de certificats SSH pour votre organisation

Pour plus de détails sur ce qui a changé dans la mise à jour plus large de macOS Tahoe 26.3, consultez notre guide de version macOS Tahoe 26.3.

Référence Rapide : Commandes dont vous avez Besoin

Voici une référence consolidée de chaque commande mentionnée dans ce guide, organisée par tâche :

Diagnostic

# Vérifier la version SSH
ssh -V

# Test de connexion détaillé
ssh -vvv user@host

# Vérifier quel binaire SSH est en cours d'exécution
which ssh

# Tester sans fichier de configuration
ssh -F /dev/null user@host

# Vérifier les types de clés actuels
for key in ~/.ssh/*.pub; do
    echo "=== $key ==="
    ssh-keygen -l -f "$key"
done

Génération de Clés

# Générer une clé Ed25519 (recommandé)
ssh-keygen -t ed25519 -C "description-YYYY" -f ~/.ssh/id_ed25519

# Générer une clé RSA (si Ed25519 n'est pas pris en charge par la cible)
ssh-keygen -t rsa -b 4096 -C "description-YYYY" -f ~/.ssh/id_rsa

Déploiement de Clés

# Déployer la clé sur le serveur distant
ssh-copy-id -i ~/.ssh/id_ed25519.pub user@host

# Ajouter la clé au Keychain macOS
ssh-add --apple-use-keychain ~/.ssh/id_ed25519

Audit de Configuration

# Trouver les références DSA dans la configuration
grep -n "ssh-dss" ~/.ssh/config /etc/ssh/ssh_config

# Trouver toutes les directives User
grep -n "User " ~/.ssh/config

# Valider la syntaxe de configuration
ssh -G test-host

# Corriger les permissions
chmod 700 ~/.ssh
chmod 600 ~/.ssh/config
chmod 400 ~/.ssh/id_*
chmod 644 ~/.ssh/*.pub

Nettoyage

# Supprimer l'ancienne clé hôte
ssh-keygen -R hostname

# Supprimer toutes les entrées DSA de known_hosts
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

Questions Fréquemment Posées

Puis-je rétrograder OpenSSH sur macOS Tahoe 26.3 pour restaurer la prise en charge DSA ?

Vous ne pouvez pas remplacer le binaire OpenSSH système sur macOS en raison de la Protection de l'Intégrité du Système (SIP). Cependant, vous pouvez installer une version plus ancienne via Homebrew ou compiler à partir des sources dans un emplacement personnalisé. Le ssh système à /usr/bin/ssh sera toujours la version OpenSSH 10.0 fournie avec Tahoe 26.3. Consultez la section "Solutions de Contournement pour l'Infrastructure Héritée" pour des instructions détaillées sur la compilation d'OpenSSH 9.7p1 à partir des sources.

Le changement de sensibilité à la casse du nom d'utilisateur est-il permanent ou un bug ?

D'après les notes de version d'OpenSSH 10.0 et la direction du projet, cela semble être un comportement intentionnel aligné sur la spécification du protocole SSH (RFC 4252), qui définit les noms d'utilisateur comme sensibles à la casse. Apple n'a pas commenté si c'est un bug et aucune indication n'indique qu'il sera annulé. Vous devriez traiter cela comme le comportement permanent et mettre à jour vos configurations en conséquence.

Mes clés RSA cesseront-elles également de fonctionner ?

Les clés RSA avec signatures SHA-2 (rsa-sha2-256 et rsa-sha2-512) continuent de fonctionner et seront prises en charge dans un avenir prévisible. Cependant, les clés RSA avec signatures SHA-1 (ssh-rsa) ont été désactivées par défaut depuis OpenSSH 8.8 et seront probablement entièrement supprimées dans une version future. Si vous utilisez des clés RSA, vérifiez qu'elles ont au moins 3072 bits et que vos serveurs acceptent les signatures SHA-2. Pour les nouvelles clés, Ed25519 est le choix préféré.

Comment corriger les connexions SSH de macOS vers Windows Server ?

L'implémentation OpenSSH de Windows Server a historiquement été insensible à la casse pour les noms d'utilisateur. Après la mise à jour de macOS Tahoe 26.3, vous devez utiliser la casse exacte que Windows reconnaît. Pour les comptes de domaine, utilisez DOMAIN\Username ou [email protected]. Pour les comptes locaux, vérifiez le nom du compte dans Gestion de l'Ordinateur. Mettez à jour votre ~/.ssh/config en conséquence :

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

Cela affecte-t-il également SFTP et SCP ?

Oui. sftp et scp utilisent tous deux la même bibliothèque client SSH et sont soumis à la même application de sensibilité à la casse et suppression de DSA. Tout client SFTP (comme Cyberduck, Transmit ou FileZilla) utilisant le binaire SSH système sera également affecté. Les clients SFTP GUI qui intègrent leur propre bibliothèque SSH (comme Cyberduck avec sa propre construction libssh2) peuvent ne pas être affectés, mais cela dépend de l'application spécifique.

Conclusion

macOS Tahoe 26.3 a livré des modifications SSH qui ont cassé des flux de travail établis sans avertissement adéquat. L'application des noms d'utilisateur sensibles à la casse, la suppression complète de DSA et les avertissements d'échange de clés post-quantiques nécessitent chacun une attention, mais ils sont tous simples à résoudre une fois que vous comprenez ce qui a changé.

Les actions immédiates à entreprendre sont :

Auditer votre ~/.ssh/config pour les inadéquations de casse dans les directives User et supprimer toutes les références ssh-dss
Générer des clés Ed25519 pour remplacer les clés DSA restantes
Déployer les nouvelles clés sur tous les serveurs de votre inventaire
Mettre à jour les scripts d'automatisation et les pipelines CI/CD avec la casse correcte du nom d'utilisateur et les chemins de clés
Réduire au silence ou résoudre les avertissements post-quantiques en fonction de votre posture de sécurité

Ces changements, bien que perturbateurs, poussent l'écosystème SSH macOS vers des valeurs par défaut de sécurité plus robustes. Ed25519 est plus rapide, plus sécurisé et produit des clés plus petites que DSA. Les noms d'utilisateur sensibles à la casse sont alignés sur la spécification du protocole SSH. L'échange de clés post-quantique protège contre les menaces futures. La douleur de la migration est réelle, mais les améliorations de sécurité sont substantielles.

Si vous configurez un nouvel environnement de développement sur macOS Tahoe, commencez par notre guide de configuration développeur macOS Tahoe pour tout configurer correctement dès le départ. Pour une configuration de sécurité plus large, notre guide de sécurité et confidentialité macOS Tahoe couvre la pile de sécurité complète au-delà de SSH.