macOS Tahoe 26.3 Quebrou o SSH: Mudanças na Sensibilidade a Maiúsculas, Remoção das Chaves DSA e Guia Completo de Correção

Q: Minhas chaves RSA também vão parar de funcionar?

Chaves RSA com assinaturas SHA-2 (rsa-sha2-256 e rsa-sha2-512) continuam funcionando e serão suportadas no futuro previsível. No entanto, chaves RSA com assinaturas SHA-1 (ssh-rsa) foram desabilitadas por padrão desde o OpenSSH 8.8 e provavelmente serão totalmente removidas em uma versão futura. Se você usa chaves RSA, verifique se são de pelo menos 3072 bits e que seus servidores aceitam assinaturas SHA-2. Para novas chaves, Ed25519 é a escolha preferida.

Q: Isso também afeta SFTP e SCP?

Sim. Tanto sftp quanto scp usam a mesma biblioteca de cliente SSH e estão sujeitos à mesma aplicação de sensibilidade a maiúsculas e remoção de DSA. Quaisquer clientes SFTP (como Cyberduck, Transmit ou FileZilla) que usam o binário SSH do sistema também serão afetados. Clientes SFTP com interface gráfica que incluem sua própria biblioteca SSH (como Cyberduck com sua própria compilação libssh2) podem não ser afetados, mas isso depende do aplicativo específico.

macOS Tahoe 26.3 alterou silenciosamente o tratamento de nomes de usuário SSH para sensível a maiúsculas e desabilitou chaves ssh-dss. Guia completo para corrigir conexões SSH, atualizar configurações e migrar para chaves Ed25519.

A Apple lançou o macOS Tahoe 26.3 em 11 de fevereiro de 2026, e para milhares de desenvolvedores e administradores de sistemas, as conexões SSH pararam de funcionar imediatamente. Sem aviso. Sem assistente de migração. Sem nota de versão descrevendo o problema. Em um dia você conseguia fazer ssh administrator@seuservidor e no dia seguinte recebia Connection closed by 10.10.83.28 port 22. Se você dependia de chaves DSA para autenticação em infraestruturas legadas, elas pararam de funcionar completamente. Este guia explica exatamente o que mudou, por que aconteceu e como corrigir cada fluxo de trabalho afetado -- desde sessões interativas até pipelines de CI/CD automatizados.

Principais Conclusões

macOS Tahoe 26.3 aplica nomes de usuário SSH sensíveis a maiúsculas. Digitar administrator em vez de Administrator agora resulta em fechamento imediato da conexão sem prompt de senha.
Chaves ssh-dss (DSA) foram permanentemente removidas. O OpenSSH 10.0, incluído no Tahoe 26.3, removeu completamente o suporte a DSA do binário. Não há flag de configuração para reativá-lo.
Avisos de troca de chaves pós-quântica agora aparecem ao conectar a servidores que não suportam mlkem768x25519-sha256 ou sntrup761x25519-sha512.
Ed25519 é o tipo de chave recomendado para todas as novas chaves SSH. É mais rápido, mais seguro e produz assinaturas menores do que RSA.
Todo arquivo ~/.ssh/config deve ser auditado para verificar inconsistências de maiúsculas em diretivas User e referências a ssh-dss em HostKeyAlgorithms ou PubkeyAcceptedAlgorithms.

Índice

O Que Exatamente Mudou no SSH do macOS Tahoe 26.3
Diagnosticando Falhas de Conexão SSH Após a Atualização
Entendendo a Mudança de Sensibilidade a Maiúsculas
Entendendo a Remoção das Chaves DSA
Avisos de Troca de Chaves Pós-Quântica
Correção Passo a Passo: Problemas de Sensibilidade a Maiúsculas
Correção Passo a Passo: Migrando de DSA para Ed25519
Guia Completo de Auditoria da Configuração SSH
Mudanças no Agente SSH e Integração com Keychain
Impacto nos Pipelines de CI/CD e Automação
Impacto nos Fluxos de Trabalho de Desenvolvimento Remoto
Soluções Alternativas para Infraestrutura Legada
Melhores Práticas de Segurança SSH para 2026
Perguntas Frequentes
Conclusão

O Que Exatamente Mudou no SSH do macOS Tahoe 26.3

O macOS Tahoe 26.3 vem com o OpenSSH 10.0, que introduz três mudanças incompatíveis que afetam os fluxos de trabalho SSH diários. A Apple não destacou nenhuma delas nas notas de versão voltadas ao usuário, deixando os desenvolvedores para descobri-las por meio de conexões com falha.

Mudança 1: Correspondência de Nome de Usuário Sensível a Maiúsculas

Antes do Tahoe 26.3, o cliente SSH no macOS era tolerante quanto às maiúsculas nos nomes de usuário. Você podia conectar com ssh administrator@servidor, ssh Administrator@servidor ou até ssh ADMINISTRATOR@servidor, e o servidor remoto resolvia o nome de usuário corretamente, desde que o sistema operacional subjacente correspondesse à conta. Após a atualização, o cliente SSH aplica correspondência estrita de maiúsculas antes mesmo de a conexão ser totalmente estabelecida. Se as maiúsculas não corresponderem ao que o servidor remoto espera, a conexão é encerrada imediatamente -- antes que a autenticação por senha ou a troca de chaves seja concluída.

Mudança 2: Remoção Completa do DSA (ssh-dss)

O OpenSSH vem descontinuando o DSA desde a versão 7.0 em 2015. A descontinuação seguiu uma linha do tempo clara:

Data	Versão OpenSSH	Status DSA
2015	7.0	Desabilitado por padrão, reabilitável via config
2024	9.x	Opcional em tempo de compilação, habilitado por padrão
Meados de 2024	9.x	Opcional em tempo de compilação, desabilitado por padrão
Abril de 2025	10.0	Removido completamente do código-fonte
Fevereiro de 2026	10.0 (macOS Tahoe 26.3)	Distribuído para todos os usuários macOS

Com o macOS Tahoe 26.3, não há solução alternativa PubkeyAcceptedAlgorithms +ssh-dss. O algoritmo não está presente no binário. Qualquer configuração SSH que referencie ssh-dss produzirá um erro Bad key types.

Mudança 3: Avisos de Troca de Chaves Pós-Quântica

O OpenSSH 10.0 introduziu um aviso que é acionado ao conectar a servidores que não suportam algoritmos de troca de chaves pós-quântica. O aviso diz:

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

Embora seja um aviso em vez de uma falha definitiva, ele cria ruído na saída do terminal e pode quebrar scripts automatizados que analisam a saída do SSH.

O Que Não Mudou

Vale notar o que permanece igual:

Chaves RSA continuam funcionando (com algoritmos de assinatura rsa-sha2-256 e rsa-sha2-512)
Chaves ECDSA continuam funcionando (embora Ed25519 seja preferido)
Encaminhamento de porta, tunelamento e ProxyJump SSH funcionam de forma idêntica
O formato do arquivo ~/.ssh/known_hosts não mudou

Se você é novo no SSH no macOS ou está configurando um ambiente de desenvolvimento do zero, nosso guia de configuração do desenvolvedor macOS Tahoe cobre a configuração inicial completa.

Diagnosticando Falhas de Conexão SSH Após a Atualização

Antes de fazer qualquer alteração, você precisa determinar qual dos três problemas está afetando suas conexões. A saída detalhada do SSH é sua principal ferramenta de diagnóstico.

Passo 1: Habilitar Saída SSH Detalhada

Execute seu comando SSH com falha com flags de verbosidade tripla para ver a negociação completa do handshake:

ssh -vvv user@hostname

Isso produz saída detalhada mostrando cada etapa da conexão. Procure por esses padrões específicos:

Padrão de falha de sensibilidade a maiúsculas:

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

O indicador-chave é que a conexão fecha após o estabelecimento, mas antes de qualquer tentativa de autenticação. Não há mensagem "Permission denied" -- a conexão simplesmente cai.

Padrão de falha de chave DSA:

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

ou:

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

Este erro aparece imediatamente quando o cliente SSH analisa seu arquivo de configuração, antes de qualquer tentativa de conexão.

Padrão de aviso pós-quântico:

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

Isso aparece durante a troca de chaves, mas não impede a conclusão da conexão.

Passo 2: Verificar a Versão do Cliente SSH

Verifique qual versão do OpenSSH está sendo executada:

ssh -V

Saída esperada no macOS Tahoe 26.3:

OpenSSH_10.0p1, LibreSSL 3.3.6

Se você ver uma versão mais antiga, pode ter um OpenSSH instalado pelo Homebrew com prioridade. Verifique qual binário está sendo usado:

which ssh

O SSH do sistema está em /usr/bin/ssh. Se você ver /opt/homebrew/bin/ssh ou /usr/local/bin/ssh, está usando uma versão do Homebrew que pode se comportar de forma diferente.

Passo 3: Testar com Parâmetros Explícitos

Isole o problema testando com maiúsculas explícitas do nome de usuário e tipo de chave:

# Testar sensibilidade a maiúsculas - tente ambos os casos
ssh -vvv Administrator@hostname
ssh -vvv administrator@hostname

# Testar sem interferência de arquivo de configuração
ssh -F /dev/null -vvv user@hostname

# Testar com uma chave específica
ssh -vvv -i ~/.ssh/id_ed25519 user@hostname

Saída de Debug SSH no Terminal

Passo 4: Revisar Arquivo de Configuração SSH para Erros

Analise seu arquivo de configuração para identificar linhas que referenciam algoritmos descontinuados:

# Verificar referências a ssh-dss
grep -n "ssh-dss" ~/.ssh/config

# Verificar referências a ssh-dss na configuração do sistema
grep -n "ssh-dss" /etc/ssh/ssh_config

# Verificar todas as diretivas User para revisão de maiúsculas
grep -n "User " ~/.ssh/config

Para uma compreensão mais aprofundada do uso do Terminal no macOS Tahoe, consulte nosso guia do Terminal macOS Tahoe.

Entendendo a Mudança de Sensibilidade a Maiúsculas

Por Que Essa Mudança Quebra Conexões

Na maioria dos sistemas Unix, os nomes de usuário são sensíveis a maiúsculas no nível do sistema operacional. Um usuário chamado Administrator é tecnicamente uma conta diferente de administrator. No entanto, o próprio protocolo SSH (RFC 4252) afirma que os nomes de usuário são "sensíveis a maiúsculas", mas reconhece que as implementações do servidor podem optar por lidar com isso de forma diferente.

Antes do macOS Tahoe 26.3, o cliente SSH do macOS era tolerante. Quando você digitava ssh administrator@servidor, o cliente enviava o nome de usuário como estava, e muitos servidores SSH (particularmente aqueles rodando no Windows, macOS ou appliances de rede) normalizavam as maiúsculas durante a autenticação. A conexão era bem-sucedida porque o servidor fazia o trabalho pesado de combinar administrator com a conta Administrator.

Com o OpenSSH 10.0, o cliente SSH no macOS agora realiza uma verificação de pré-autenticação mais rígida. Se o servidor retornar uma mensagem de protocolo antecipada indicando uma incompatibilidade de maiúsculas, a conexão é encerrada antes que a autenticação prossiga. Isso significa que:

Conexões com servidores Windows (que historicamente normalizavam maiúsculas) podem quebrar
Conexões com appliances de rede (roteadores, switches, dispositivos NAS) que usam nomes de usuário sem distinção de maiúsculas podem quebrar
Conexões com servidores macOS onde a conta de administrador é Administrator (A maiúscula), mas scripts usam administrator (minúsculo) vão quebrar
Conexões com servidores Linux têm menos probabilidade de ser afetadas, pois os nomes de usuário do Linux já são sensíveis a maiúsculas

Cenários Comuns Que Quebram

Cenário 1: Gerenciamento Remoto de macOS para macOS

Muitos administradores de sistemas conectam a Macs remotos usando:

ssh [email protected]

Mas a conta de administrador padrão do macOS é criada como Administrator com A maiúsculo. Isso funcionava antes do Tahoe 26.3 e quebra depois.

Cenário 2: Gerenciamento de Appliances de Rede

Conectar a roteadores, switches, firewalls e dispositivos NAS frequentemente usa nomes de usuário genéricos:

ssh [email protected]
ssh [email protected]

Se o dispositivo armazenar o nome de usuário como Admin ou ROOT, essas conexões agora falharão silenciosamente.

Cenário 3: Aliases de Configuração SSH

Muitos desenvolvedores têm entradas de configuração SSH com maiúsculas incorretas que funcionavam anteriormente:

# ~/.ssh/config - isso pode quebrar agora
Host production
    HostName prod.example.com
    User deploy      # Servidor espera "Deploy"
    IdentityFile ~/.ssh/prod_key

Entendendo a Remoção das Chaves DSA

O Caso de Segurança Contra DSA

O DSA (Digital Signature Algorithm), implementado em SSH, usa um comprimento de chave fixo de 1024 bits e SHA-1 para hashing. Essa combinação fornece aproximadamente 80 bits de segurança simétrica -- muito abaixo do mínimo de 128 bits recomendado pelos padrões modernos de segurança.

As fraquezas específicas das chaves DSA:

Propriedade	DSA (ssh-dss)	Ed25519	RSA-4096
Tamanho da chave	1024 bits	256 bits	4096 bits
Algoritmo de hash	SHA-1	SHA-512	SHA-256/512
Nível de segurança	~80 bits	~128 bits	~128 bits
Tamanho da assinatura	40 bytes	64 bytes	512 bytes
Velocidade de assinatura	Lenta	Rápida	Moderada
Velocidade de verificação	Lenta	Rápida	Moderada
Vulnerabilidade a viés	Alta	Nenhuma	Nenhuma

O DSA é particularmente vulnerável a falhas de implementação. Se o gerador de números aleatórios usado durante a assinatura tiver qualquer viés, a chave privada pode ser recuperada a partir de um pequeno número de assinaturas. Isso foi explorado em ataques reais.

O Que "Removido" Realmente Significa

Em versões anteriores do macOS, o DSA era desabilitado por padrão, mas podia ser reabilitado com opções de configuração:

# Isso costumava funcionar no macOS Sequoia e anteriores
Host legacy-server
    HostKeyAlgorithms +ssh-dss
    PubkeyAcceptedAlgorithms +ssh-dss

No macOS Tahoe 26.3, essas linhas de configuração em si causam erros porque o binário SSH não reconhece mais ssh-dss como um identificador de algoritmo válido. O erro é:

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

Isso significa:

Você não pode usar chaves DSA para autenticação (login por chave pública)
Você não pode aceitar chaves de host DSA de servidores
Você não pode nem mesmo referenciar ssh-dss em seus arquivos de configuração sem causar erros
A ferramenta ssh-keygen não pode mais gerar chaves DSA

Verificando Se Você Tem Chaves DSA

Antes de prosseguir com a migração, verifique suas chaves existentes:

# Listar todas as chaves SSH com seus tipos
for key in ~/.ssh/*.pub; do
    echo "=== $key ==="
    ssh-keygen -l -f "$key"
done

Saída de exemplo:

=== /Users/you/.ssh/id_dsa.pub ===
1024 SHA256:abc123... you@mac (DSA)          # Esta chave deve ser substituída
=== /Users/you/.ssh/id_ed25519.pub ===
256 SHA256:xyz789... you@mac (ED25519)       # Esta chave está ok
=== /Users/you/.ssh/id_rsa.pub ===
3072 SHA256:def456... you@mac (RSA)          # Esta chave está ok

Qualquer chave identificada como (DSA) deve ser substituída. Se você encontrar uma, não a exclua ainda -- você precisa dela para identificar quais servidores a têm autorizada.

Avisos de Troca de Chaves Pós-Quântica

O Que o Aviso Significa

O OpenSSH 10.0 introduziu troca de chaves pós-quântica usando o algoritmo ML-KEM (anteriormente CRYSTALS-Kyber) hibridizado com X25519. O algoritmo de troca de chaves padrão é agora mlkem768x25519-sha256, com sntrup761x25519-sha512 como alternativa.

Ao conectar a um servidor que não suporta nenhum desses algoritmos, o OpenSSH exibe:

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

Um ataque "armazenar agora, decifrar depois" significa que um adversário poderia registrar seu tráfego SSH criptografado hoje e descriptografá-lo no futuro, quando os computadores quânticos se tornarem capazes de quebrar algoritmos clássicos de troca de chaves.

Quando Você Verá Este Aviso

Conectando a servidores rodando OpenSSH 8.x ou anterior
Conectando a appliances de rede com implementações SSH embarcadas
Conectando a instâncias na nuvem com versões mais antigas do daemon SSH
Conectando ao GitHub, GitLab ou Bitbucket (pode ou não suportar algoritmos PQ ainda)

Silenciando o Aviso

Se você entende o risco e quer suprimir o aviso, adicione isso ao seu ~/.ssh/config:

# Suprimir avisos pós-quânticos globalmente
Host *
    WarnWeakCrypto no

Ou apenas para hosts específicos:

Host legacy-server
    HostName 192.168.1.100
    WarnWeakCrypto no

A solução ideal é atualizar seus servidores para OpenSSH 9.0 ou posterior, que suporta sntrup761x25519-sha512, ou OpenSSH 9.9+, que suporta o mais novo mlkem768x25519-sha256.

Correção Passo a Passo: Problemas de Sensibilidade a Maiúsculas

Correção 1: Determinar o Caso Correto do Nome de Usuário

Primeiro, verifique o nome de usuário exato no sistema remoto. O método depende do SO remoto:

Para servidores Linux/macOS remotos:

# Se você ainda puder fazer login via console, acesso físico ou outro cliente SSH
grep "seu_usuario" /etc/passwd

# Ou use o comando id
id

# Saída de exemplo: uid=501(Administrator) gid=20(staff) groups=...

Para servidores Windows remotos (OpenSSH):

# No PowerShell na máquina remota
whoami
# Saída: DOMAIN\Administrator

Para appliances de rede:

Verifique a interface de gerenciamento web do dispositivo ou documentação para o formato exato do nome de usuário. Padrões comuns:

Cisco IOS: geralmente minúsculas (admin)
Juniper: geralmente minúsculas (root)
Synology NAS: sensível a maiúsculas conforme criado
QNAP NAS: sensível a maiúsculas conforme criado

Correção 2: Atualizar Seu Arquivo de Configuração SSH

Abra sua configuração SSH e corrija todas as diretivas User:

# Abrir o arquivo de configuração
nano ~/.ssh/config

Antes (quebrado):

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

Host nas
    HostName nas.local
    User admin
    Port 22

Depois (corrigido):

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

Host nas
    HostName nas.local
    User Admin
    Port 22

Correção 3: Atualizar Aliases de Shell e Scripts

Procure por comandos SSH em sua configuração de shell:

# Verificar aliases bash
grep -n "ssh " ~/.bashrc ~/.bash_profile 2>/dev/null

# Verificar aliases zsh
grep -n "ssh " ~/.zshrc ~/.zprofile 2>/dev/null

# Verificar comandos SSH em scripts personalizados
grep -rn "ssh " ~/scripts/ ~/bin/ 2>/dev/null

Atualize quaisquer nomes de usuário codificados para usar o caso correto.

Correção 4: Atualizar Variáveis de Ambiente

Algumas ferramentas usam variáveis de ambiente para nomes de usuário SSH:

# Verificar variáveis de ambiente relacionadas a SSH
env | grep -i ssh
env | grep -i user

# Variáveis comuns a verificar
echo $DEPLOY_USER
echo $SSH_USER
echo $REMOTE_USER

Correção 5: Verificar a Correção

Após fazer alterações, verifique cada conexão:

# Testar com saída detalhada
ssh -v production

# Esperado: autenticação bem-sucedida
# debug1: Authentication succeeded (publickey).

Correção Passo a Passo: Migrando de DSA para Ed25519

Esta seção percorre o processo completo de substituição de chaves DSA por chaves Ed25519. Se você precisar de informações sobre comandos do Terminal, nosso guia de domínio do Terminal Mac cobre todos os fundamentos.

Fluxo de Migração de Chaves SSH

Fase 1: Inventariar Suas Chaves DSA

Antes de gerar novas chaves, documente onde suas chaves DSA são usadas:

# Passo 1: Encontrar todas as chaves DSA no seu sistema
find ~/.ssh -name "*.pub" -exec grep -l "ssh-dss" {} \;

# Passo 2: Para cada chave DSA, verificar quais servidores a autorizam
# Anote a impressão digital da chave pública
ssh-keygen -l -f ~/.ssh/id_dsa.pub

# Passo 3: Verificar known_hosts para chaves de host DSA
grep "ssh-dss" ~/.ssh/known_hosts | awk '{print $1}'

Crie uma lista de verificação de migração:

# Criar um arquivo de rastreamento de migração
cat > ~/ssh_migration_checklist.txt << 'EOF'
SSH DSA Key Migration Checklist
===============================
Date: $(date)

DSA Keys Found:
- [ ] ~/.ssh/id_dsa -> Used for: _______________
- [ ] ~/.ssh/id_dsa.pub -> Authorized on: _______________

Servers with DSA Host Keys:
- [ ] server1.example.com
- [ ] 192.168.1.100

Automation/Scripts Using DSA:
- [ ] deploy.sh
- [ ] backup-cron.sh
- [ ] CI/CD pipeline: _______________
EOF

Fase 2: Gerar Novas Chaves Ed25519

Gere um novo par de chaves Ed25519 com um comentário significativo:

# Gerar chave Ed25519 com comentário descritivo
ssh-keygen -t ed25519 -C "seunome@macbook-2026-02" -f ~/.ssh/id_ed25519

# Você será solicitado a fornecer uma senha -- USE UMA
# Uma senha protege sua chave privada se sua máquina for comprometida

Se precisar de chaves separadas para diferentes propósitos (recomendado para isolamento de segurança):

# Chave para servidores de trabalho
ssh-keygen -t ed25519 -C "work-servers-2026" -f ~/.ssh/id_ed25519_work

# Chave para projetos pessoais
ssh-keygen -t ed25519 -C "personal-2026" -f ~/.ssh/id_ed25519_personal

# Chave para automação de CI/CD
ssh-keygen -t ed25519 -C "cicd-automation-2026" -f ~/.ssh/id_ed25519_cicd

Verifique as chaves geradas:

# Verificar a nova chave
ssh-keygen -l -f ~/.ssh/id_ed25519.pub

# Saída esperada:
# 256 SHA256:abcdef123456... seunome@macbook-2026-02 (ED25519)

Fase 3: Implantar Novas Chaves nos Servidores

Para cada servidor que anteriormente usava sua chave DSA, implante a nova chave pública Ed25519:

Método 1: Usando ssh-copy-id (se você ainda puder autenticar)

Se você tiver outro método de autenticação funcional (senha, chave diferente):

# Implantar a nova chave usando autenticação por senha
ssh-copy-id -i ~/.ssh/id_ed25519.pub user@server

# Ou especificar uma chave funcional para autenticação durante a implantação
ssh-copy-id -i ~/.ssh/id_ed25519.pub -o "IdentityFile=~/.ssh/id_rsa" user@server

Método 2: Implantação manual (se ssh-copy-id não estiver disponível)

# Copiar o conteúdo da chave pública
cat ~/.ssh/id_ed25519.pub | pbcopy

# SSH no servidor usando o método que funciona (senha, console, etc.)
ssh user@server

# No servidor remoto, adicionar a chave
mkdir -p ~/.ssh
chmod 700 ~/.ssh
echo "COLE_SUA_CHAVE_PUBLICA_AQUI" >> ~/.ssh/authorized_keys
chmod 600 ~/.ssh/authorized_keys

Método 3: Para servidores nos quais você não pode fazer SSH

Se a chave DSA era seu único método de autenticação e não funciona mais:

Use o console de gerenciamento web do servidor (se disponível)
Acesse via console físico ou IPMI/iLO/iDRAC
Use um host de salto que ainda tem acesso
Entre em contato com o administrador do servidor

Fase 4: Atualizar Configuração SSH

Substitua referências de chaves DSA na sua configuração SSH:

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

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

Fase 5: Limpar Hosts Conhecidos

Remova entradas de chaves de host DSA obsoletas:

# Encontrar servidores com chaves de host DSA em known_hosts
grep "ssh-dss" ~/.ssh/known_hosts

# Remover entradas de host específicas (a chave de host será re-aceita na próxima conexão)
ssh-keygen -R hostname_ou_ip

# Ou remover todas as entradas DSA de uma vez
# Primeiro faça backup do arquivo
cp ~/.ssh/known_hosts ~/.ssh/known_hosts.backup.$(date +%Y%m%d)

# Em seguida, remover entradas DSA
grep -v "ssh-dss" ~/.ssh/known_hosts > ~/.ssh/known_hosts.tmp
mv ~/.ssh/known_hosts.tmp ~/.ssh/known_hosts

Fase 6: Verificar Se Tudo Funciona

Teste cada conexão com servidor:

# Testar conexões com saída detalhada
ssh -v old-server

# Verificar se a chave correta está sendo oferecida
# Procure por: debug1: Offering public key: /Users/you/.ssh/id_ed25519_work ED25519

# Executar um teste de conectividade completo para todos os hosts configurados
for host in $(grep "^Host " ~/.ssh/config | awk '{print $2}' | grep -v '\*'); do
    echo "Testing: $host"
    ssh -o ConnectTimeout=5 -o BatchMode=yes "$host" echo "OK" 2>&1
    echo "---"
done

Fase 7: Aposentar a Chave DSA

Uma vez que todos os servidores estejam migrados e verificados:

# Arquivar as chaves DSA antigas (não exclua imediatamente)
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.*

Mantenha as chaves arquivadas por pelo menos 90 dias, caso descubra um servidor que você perdeu.

Guia Completo de Auditoria da Configuração SSH

Após resolver problemas individuais, realize uma auditoria completa da sua configuração SSH. Isso é especialmente importante se você usa SSH no macOS há anos e acumulou entradas de configuração ao longo de múltiplas atualizações do macOS.

Auditoria Passo 1: Verificar Algoritmos Descontinuados

# Verificar QUALQUER referência de algoritmo descontinuado
echo "=== Verificando ~/.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 "=== Verificando /etc/ssh/ssh_config ==="
grep -n -E "(ssh-dss|ssh-dsa|diffie-hellman-group1-sha1)" /etc/ssh/ssh_config 2>/dev/null

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

Auditoria Passo 2: Validar Sintaxe da Configuração

# Testar sintaxe da configuração SSH sem conectar
ssh -G test-host 2>&1 | head -5

# Se houver erros, eles aparecerão como:
# /Users/you/.ssh/config line X: Bad key types '...'

Auditoria Passo 3: Revisar Todas as Diretivas User

# Extrair todas as diretivas User e os hosts a que se aplicam
awk '/^Host /{host=$2} /User /{print host, $0}' ~/.ssh/config

Revise a saída e verifique as maiúsculas de cada nome de usuário.

Auditoria Passo 4: Verificar Permissões de Arquivo

O SSH é rigoroso quanto às permissões de arquivo. Permissões incorretas podem causar falhas silenciosas:

# Verificar e corrigir permissões do diretório SSH
echo "=== Permissões de diretório ==="
ls -la ~/.ssh/

echo ""
echo "=== Permissões esperadas ==="
echo "~/.ssh/           -> drwx------ (700)"
echo "~/.ssh/config     -> -rw------- (600)"
echo "~/.ssh/id_*       -> -rw------- (600) para chaves privadas"
echo "~/.ssh/*.pub      -> -rw-r--r-- (644) para chaves públicas"
echo "~/.ssh/authorized_keys -> -rw------- (600)"
echo "~/.ssh/known_hosts     -> -rw-r--r-- (644)"

# Corrigir permissões se necessário
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

Auditoria Passo 5: Modelo de Configuração SSH Moderno Recomendado

Aqui está um modelo completo e moderno de configuração SSH que funciona com o macOS Tahoe 26.3:

# ~/.ssh/config
# Atualizado para macOS Tahoe 26.3 / OpenSSH 10.0
# Última auditoria: 2026-02-28

# ============================================
# Padrões globais
# ============================================
Host *
    # Usar chaves Ed25519 por padrão
    IdentityFile ~/.ssh/id_ed25519

    # Oferecer apenas chaves explicitamente configuradas para cada host
    IdentitiesOnly yes

    # Integração com Keychain do macOS
    UseKeychain yes
    AddKeysToAgent yes

    # Preferências modernas de troca de chaves
    KexAlgorithms mlkem768x25519-sha256,[email protected],curve25519-sha256,[email protected]

    # Estabilidade de conexão
    ServerAliveInterval 60
    ServerAliveCountMax 3

    # Fortalecimento de segurança
    HashKnownHosts yes
    StrictHostKeyChecking ask

# ============================================
# Servidores de trabalho
# ============================================
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

# ============================================
# Servidores pessoais
# ============================================
Host homelab
    HostName 192.168.1.100
    User admin
    IdentityFile ~/.ssh/id_ed25519_personal

# ============================================
# Configuração de host de salto
# ============================================
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

Mudanças no Agente SSH e Integração com Keychain

O macOS Tahoe 26.3 também traz mudanças sutis em como o agente SSH interage com o macOS Keychain.

Integração com Keychain

A diretiva específica do macOS UseKeychain continua funcionando no Tahoe 26.3, mas seu comportamento foi refinado:

# Adicionar sua nova chave Ed25519 ao macOS Keychain
ssh-add --apple-use-keychain ~/.ssh/id_ed25519

# Verificar se a chave foi adicionada
ssh-add -l

Se a chave foi adicionada com sucesso, você verá:

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

Carregamento Persistente de Chaves

Certifique-se de que sua configuração SSH inclua essas diretivas para manter a persistência das chaves após reinicializações:

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

Sem UseKeychain yes, você precisará executar ssh-add após cada reinicialização.

Verificando o Agente SSH

# Verificar se o agente está rodando
echo $SSH_AUTH_SOCK

# Listar chaves carregadas
ssh-add -l

# Se nenhuma chave estiver carregada, adicione-as
ssh-add --apple-use-keychain ~/.ssh/id_ed25519

Para mais detalhes sobre configurações de segurança do macOS, veja nosso guia de segurança e privacidade do macOS Tahoe.

Impacto nos Pipelines de CI/CD e Automação

As mudanças SSH no macOS Tahoe 26.3 têm implicações significativas para fluxos de trabalho automatizados. Se seu pipeline de CI/CD roda em runners macOS (GitHub Actions, GitLab CI, Jenkins no Mac), essas mudanças afetarão você após a atualização do SO do runner.

GitHub Actions

Se você usa runners macos-latest ou macos-15, o binário SSH eventualmente será atualizado. Audite seus workflows agora:

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

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

Verifique seus segredos de implantação:

DEPLOY_USER -- verifique se as maiúsculas correspondem à conta remota
SSH_PRIVATE_KEY -- verifique se não é uma chave DSA
KNOWN_HOSTS -- verifique se não há entradas de chave de host DSA

GitLab CI

# .gitlab-ci.yml
deploy:
  before_script:
    # Verificar tipo de chave antes de implantar
    - ssh-keygen -l -f ~/.ssh/id_deploy
    # Garantir que NÃO seja DSA
    - |
      if ssh-keygen -l -f ~/.ssh/id_deploy | grep -q "DSA"; then
        echo "ERROR: DSA key detected. Migration required."
        exit 1
      fi
  script:
    # Usar maiúsculas corretas para nome de usuário
    - ssh -o StrictHostKeyChecking=no Deploy@$DEPLOY_HOST "deploy.sh"

Jenkins

Para pipelines Jenkins rodando em agentes macOS:

pipeline {
    agent { label 'macos' }
    stages {
        stage('Pre-flight SSH Check') {
            steps {
                sh '''
                    # Verificar versão SSH
                    ssh -V

                    # Verificar chaves DSA nas credenciais
                    for key in ~/.ssh/*.pub; do
                        if ssh-keygen -l -f "$key" | grep -q "DSA"; then
                            echo "WARNING: DSA key found: $key"
                            exit 1
                        fi
                    done

                    echo "SSH pre-flight check passed"
                '''
            }
        }
    }
}

Playbooks Ansible

Se você executa o Ansible a partir de um nó de controle macOS:

# ansible.cfg
[defaults]
# Garantir binário SSH correto
ssh_executable = /usr/bin/ssh

# Forçar argumentos SSH específicos
[ssh_connection]
ssh_args = -o IdentitiesOnly=yes -o IdentityFile=~/.ssh/id_ed25519_ansible

Verifique seu inventário Ansible quanto às maiúsculas do nome de usuário:

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

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

Scripts de Backup Automatizados

Revise quaisquer cron jobs ou tarefas launchd que usem SSH:

# Encontrar todos os cron jobs com referências SSH
crontab -l 2>/dev/null | grep -i ssh

# Encontrar plists launchd com referências SSH
grep -rl "ssh" ~/Library/LaunchAgents/ /Library/LaunchAgents/ /Library/LaunchDaemons/ 2>/dev/null

# Verificar scripts de backup rsync (rsync usa SSH por padrão)
grep -rn "rsync.*@" ~/scripts/ ~/bin/ 2>/dev/null

Impacto nos Fluxos de Trabalho de Desenvolvimento Remoto

VS Code Remote SSH

A extensão Remote SSH do Visual Studio Code armazena configurações de conexão que podem ser afetadas:

# Localização da configuração SSH do VS Code
cat ~/Library/Application\ Support/Code/User/settings.json | grep -A5 "remote.SSH"

# Verificar referências SSH do VS Code
grep -n "ssh" ~/Library/Application\ Support/Code/User/settings.json 2>/dev/null

Atualize seus alvos SSH do VS Code para usar maiúsculas corretas no nome de usuário e chaves não-DSA.

JetBrains Gateway / Desenvolvimento Remoto

IDEs JetBrains armazenam configurações SSH separadamente:

# Verificar configurações SSH do JetBrains
find ~/Library/Application\ Support/JetBrains -name "*.xml" -exec grep -l "ssh" {} \; 2>/dev/null

tmux e Sessões Persistentes

Se você usa tmux ou screen via SSH, seus scripts de reconexão precisam ser atualizados:

# Alias comum de reconexão tmux - verificar maiúsculas do nome de usuário
alias tm='ssh -t Administrator@server "tmux attach || tmux new"'

Para uma configuração completa do ambiente de desenvolvedor, consulte nosso guia definitivo do desenvolvedor macOS Tahoe.

Soluções Alternativas para Infraestrutura Legada

Alguns ambientes não podem ser atualizados imediatamente. Appliances de rede, sistemas embarcados e servidores legados podem exigir DSA por anos. Aqui estão soluções alternativas práticas, ordenadas da mais para a menos recomendada.

Solução Alternativa 1: Use um Host de Salto (Recomendado)

Configure um host bastião Linux que ainda suporte DSA e use-o como 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

O host bastião executa um OpenSSH mais antigo (ou um compilado com suporte a DSA) e lida com a negociação DSA com o dispositivo legado. Seu Mac só precisa autenticar no bastião usando Ed25519.

Solução Alternativa 2: Use um Contêiner Docker

Execute um cliente OpenSSH mais antigo dentro de um contêiner Docker:

# Criar um Dockerfile para SSH legado
cat > ~/legacy-ssh/Dockerfile << 'EOF'
FROM alpine:3.18
RUN apk add --no-cache openssh-client
ENTRYPOINT ["ssh"]
EOF

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

# Usar para conectar a dispositivos legados
docker run --rm -it \
    -v ~/.ssh:/root/.ssh:ro \
    legacy-ssh \
    -o HostKeyAlgorithms=+ssh-dss \
    -o PubkeyAcceptedKeyTypes=+ssh-dss \
    admin@legacy-device

Crie um alias de shell para conveniência:

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

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

Solução Alternativa 3: Instalar um OpenSSH Mais Antigo via Homebrew

Você pode compilar o OpenSSH 9.7p1 (a última versão com suporte DSA) a partir do código-fonte:

# Instalar dependências
brew install openssl@3

# Baixar código-fonte do 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

# Configurar com suporte DSA e prefixo personalizado
./configure \
    --prefix=$HOME/openssh97 \
    --with-ssl-dir=$(brew --prefix openssl@3)

# Compilar e instalar
make -j$(sysctl -n hw.ncpu)
make install

# Usar o binário SSH mais antigo
~/openssh97/bin/ssh -o HostKeyAlgorithms=+ssh-dss admin@legacy-device

Crie um alias para conexões legadas:

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

# Uso
ssh-legacy admin@old-router

Solução Alternativa 4: Use uma Máquina Virtual Linux

Se você usa UTM, Parallels ou VMware Fusion:

Configure uma VM Linux leve (Alpine ou Ubuntu Server)
Faça SSH do seu Mac para a VM (usando Ed25519)
Da VM, faça SSH para o dispositivo legado (usando DSA)

Isso fornece isolamento completo e não requer a modificação da instalação SSH do macOS.

Longo Prazo: Planeje a Substituição de Dispositivos

Se você está dependendo do DSA porque seus appliances de rede não suportam algoritmos modernos, isso é um sinal claro de que esses dispositivos chegaram ao fim de vida de uma perspectiva de segurança. Planeje um cronograma de substituição:

Roteadores/Switches: A maioria dos fornecedores empresariais suporta Ed25519 desde 2018
Dispositivos NAS: Synology, QNAP e TrueNAS todos suportam Ed25519
Servidores legados: Se rodando OpenSSH mais antigo que 6.5, o sistema inteiro precisa de atualização

Melhores Práticas de Segurança SSH para 2026

Com as mudanças do macOS Tahoe 26.3 como catalisador, agora é um bom momento para implementar melhorias abrangentes de segurança SSH.

Melhores Práticas de Gerenciamento de Chaves

1. Use chaves separadas para funções separadas:

# Infraestrutura de trabalho
ssh-keygen -t ed25519 -f ~/.ssh/id_ed25519_work -C "work-2026"

# Projetos pessoais
ssh-keygen -t ed25519 -f ~/.ssh/id_ed25519_personal -C "personal-2026"

# CI/CD e automação
ssh-keygen -t ed25519 -f ~/.ssh/id_ed25519_automation -C "automation-2026"

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

2. Sempre use uma senha:

Uma senha criptografa sua chave privada em repouso. Se sua máquina for comprometida, o atacante não pode usar suas chaves SSH sem a senha. Combinada com a integração do Keychain do macOS, você só precisa digitar a senha uma vez.

# Quando solicitado durante a geração de chaves:
Enter passphrase (empty for no passphrase): [insira uma senha forte]
Enter same passphrase again: [confirme]

3. Rotacione chaves anualmente:

Inclua o ano nos comentários de suas chaves para que você saiba quando foram geradas:

ssh-keygen -t ed25519 -C "voce@empresa-2026-Q1" -f ~/.ssh/id_ed25519_work_2026

Quando o ano virar, gere novas chaves, implante-as e aposente as antigas.

4. Defina permissões corretas de arquivo:

# Chaves privadas: somente leitura pelo proprietário
chmod 400 ~/.ssh/id_ed25519*
chmod 600 ~/.ssh/id_ed25519*.pub

# Na verdade, chaves públicas podem ser legíveis por todos
chmod 644 ~/.ssh/id_ed25519*.pub

# Diretório SSH em si
chmod 700 ~/.ssh

# Arquivo de configuração
chmod 600 ~/.ssh/config

Fortalecimento do Lado do Servidor

Se você gerencia servidores SSH, aproveite esta oportunidade para fortalecê-los:

# /etc/ssh/sshd_config configurações recomendadas

# Desabilitar autenticação por senha (usar apenas chaves)
 PasswordAuthentication no

# Desabilitar login root
 PermitRootLogin no

# Permitir apenas usuários específicos
AllowUsers deploy admin

# Usar troca de chaves moderna
KexAlgorithms mlkem768x25519-sha256,[email protected],curve25519-sha256

# Usar algoritmos de chave de host modernos
HostKeyAlgorithms ssh-ed25519,rsa-sha2-512,rsa-sha2-256

# Usar cifras modernas
Ciphers [email protected],[email protected],[email protected]

# Usar MACs modernos
MACs [email protected],[email protected]

# Limitação de taxa
MaxAuthTries 3
MaxSessions 5
LoginGraceTime 30

Após alterar sshd_config, sempre teste antes de desconectar:

# Validar a configuração
sudo sshd -t

# Se não houver erros, reinicie o sshd
sudo systemctl restart sshd

# IMPORTANTE: Mantenha sua sessão atual aberta e teste com uma NOVA conexão
# antes de fechar a existente

Monitoramento e Alertas

Configure o monitoramento para eventos de autenticação SSH:

# Monitorar auth.log para tentativas com falha (servidores Linux)
tail -f /var/log/auth.log | grep "sshd"

# Monitorar log do sistema macOS para eventos SSH
log stream --predicate 'process == "sshd"' --level info

Solução de Problemas de Erros Comuns

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

Causa: Incompatibilidade de maiúsculas no nome de usuário.

Correção:

# Determinar o nome de usuário correto
ssh -vvv user@host 2>&1 | grep "debug1: Sending"

# Tente o caso oposto
ssh Administrator@host  # se 'administrator' falhou
ssh administrator@host  # se 'Administrator' falhou

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

Causa: A configuração SSH referencia o algoritmo DSA removido.

Correção:

# Encontrar e editar a linha problemática
grep -n "ssh-dss" ~/.ssh/config

# Remover ou substituir a referência do algoritmo
# Antes: HostKeyAlgorithms +ssh-dss
# Depois: (remover a linha inteira, ou substituir por algoritmos modernos)

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

Causa: A configuração SSH tem uma lista composta de algoritmos incluindo DSA.

Correção:

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

# Depois (remover ssh-dss, manter ssh-rsa se necessário para RSA legado)
HostKeyAlgorithms +ssh-rsa
PubkeyAcceptedAlgorithms +ssh-rsa

Nota: ssh-rsa (com assinaturas SHA-1) também está descontinuado. Use rsa-sha2-256 ou rsa-sha2-512 se precisar usar RSA:

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

Erro: "No matching host key type found"

Causa: O servidor remoto oferece apenas chaves de host DSA.

Correção: Isso requer ação no lado do servidor. Gere novas chaves de host no servidor:

# No servidor remoto (se você tiver acesso ao 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

Se você não puder atualizar o servidor, use as soluções alternativas de host de salto ou Docker descritas acima.

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

Causa: O servidor remoto não suporta troca de chaves pós-quântica.

Correção:

# Suprimir para um host específico
# Adicione ao ~/.ssh/config:
Host old-server
    WarnWeakCrypto no

# Ou suprimir globalmente (não recomendado)
Host *
    WarnWeakCrypto no

Erro: "Permission denied (publickey)"

Causa: Após a migração de chaves, a nova chave não está autorizada no servidor.

Correção:

# Verificar qual chave está sendo oferecida
ssh -v user@host 2>&1 | grep "Offering public key"

# Implantar a chave correta
ssh-copy-id -i ~/.ssh/id_ed25519.pub user@host

Erro: "WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED"

Causa: Após remover entradas de chave de host DSA de known_hosts, o servidor está oferecendo um tipo diferente de chave de host.

Correção:

# Remover a entrada de chave de host antiga
ssh-keygen -R hostname

# Reconectar e aceitar a nova chave de host
ssh user@hostname
# Você será solicitado a verificar a nova impressão digital da chave de host

Entendendo o Contexto Mais Amplo

As mudanças SSH no macOS Tahoe 26.3 fazem parte de uma tendência mais ampla em toda a indústria. Entender esse contexto ajuda você a se preparar para mudanças futuras em vez de reagir a cada uma delas.

Linha do Tempo das Versões do OpenSSH

Versão	Data	Principais Mudanças
7.0	2015	DSA desabilitado por padrão
8.2	2020	Assinaturas SHA-1 descontinuadas para RSA
8.8	2022	Assinaturas RSA SHA-1 desabilitadas por padrão
9.0	2022	Post-quantum KEx (sntrup761) habilitado por padrão
9.9	2024	Suporte post-quantum ML-KEM adicionado
10.0	2025	DSA removido completamente, ML-KEM padrão

O macOS historicamente ficou para trás dessas versões em 6-12 meses, razão pela qual a remoção do DSA está afetando os usuários do macOS no início de 2026, apesar de estar no OpenSSH 10.0 desde abril de 2025.

O Que Esperar a Seguir

Com base no roteiro de desenvolvimento do OpenSSH:

Assinaturas RSA SHA-1 (ssh-rsa) provavelmente serão totalmente removidas no OpenSSH 11.x
ECDSA com curvas NIST pode ser descontinuado em favor do Ed25519
Assinaturas pós-quânticas (não apenas troca de chaves) serão adicionadas
Autenticação baseada em certificados será cada vez mais promovida em vez de chaves públicas brutas

Prepare-se agora:

Garantindo que todas as suas chaves sejam Ed25519
Movendo para rsa-sha2-256/512 se precisar usar RSA
Testando troca de chaves pós-quântica com seus servidores
Avaliando infraestrutura de certificados SSH para sua organização

Para mais detalhes sobre o que mudou na atualização mais ampla do macOS Tahoe 26.3, veja nosso guia de versão do macOS Tahoe 26.3.

Referência Rápida: Comandos Que Você Precisa

Aqui está uma referência consolidada de todos os comandos mencionados neste guia, organizados por tarefa:

Diagnóstico

# Verificar versão SSH
ssh -V

# Teste de conexão detalhada
ssh -vvv user@host

# Verificar qual binário SSH está rodando
which ssh

# Testar sem arquivo de configuração
ssh -F /dev/null user@host

# Verificar tipos de chave atuais
for key in ~/.ssh/*.pub; do
    echo "=== $key ==="
    ssh-keygen -l -f "$key"
done

Geração de Chaves

# Gerar chave Ed25519 (recomendado)
ssh-keygen -t ed25519 -C "descricao-AAAA" -f ~/.ssh/id_ed25519

# Gerar chave RSA (se Ed25519 não for suportado pelo alvo)
ssh-keygen -t rsa -b 4096 -C "descricao-AAAA" -f ~/.ssh/id_rsa

Implantação de Chaves

# Implantar chave no servidor remoto
ssh-copy-id -i ~/.ssh/id_ed25519.pub user@host

# Adicionar chave ao Keychain do macOS
ssh-add --apple-use-keychain ~/.ssh/id_ed25519

Auditoria de Configuração

# Encontrar referências DSA na configuração
grep -n "ssh-dss" ~/.ssh/config /etc/ssh/ssh_config

# Encontrar todas as diretivas User
grep -n "User " ~/.ssh/config

# Validar sintaxe de configuração
ssh -G test-host

# Corrigir permissões
chmod 700 ~/.ssh
chmod 600 ~/.ssh/config
chmod 400 ~/.ssh/id_*
chmod 644 ~/.ssh/*.pub

Limpeza

# Remover chave de host antiga
ssh-keygen -R hostname

# Remover todas as entradas 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

Perguntas Frequentes

Posso fazer downgrade do OpenSSH no macOS Tahoe 26.3 para restaurar o suporte DSA?

Você não pode substituir o binário do sistema OpenSSH no macOS devido à Proteção de Integridade do Sistema (SIP). No entanto, você pode instalar uma versão mais antiga via Homebrew ou compilar a partir do código-fonte para um local personalizado. O ssh do sistema em /usr/bin/ssh sempre será a versão OpenSSH 10.0 que acompanha o Tahoe 26.3. Consulte a seção "Soluções Alternativas para Infraestrutura Legada" para instruções detalhadas sobre como compilar o OpenSSH 9.7p1 a partir do código-fonte.

A mudança de sensibilidade a maiúsculas é permanente ou um bug?

Com base nas notas de versão do OpenSSH 10.0 e na direção do projeto, isso parece ser um comportamento intencional alinhado com a especificação do protocolo SSH (RFC 4252), que define os nomes de usuário como sensíveis a maiúsculas. A Apple não comentou se isso é um bug, e não há indicação de que será revertido. Você deve tratar isso como comportamento permanente e atualizar suas configurações de acordo.

Minhas chaves RSA também vão parar de funcionar?

Chaves RSA com assinaturas SHA-2 (rsa-sha2-256 e rsa-sha2-512) continuam funcionando e serão suportadas no futuro previsível. No entanto, chaves RSA com assinaturas SHA-1 (ssh-rsa) foram desabilitadas por padrão desde o OpenSSH 8.8 e provavelmente serão totalmente removidas em uma versão futura. Se você usa chaves RSA, verifique se são de pelo menos 3072 bits e que seus servidores aceitam assinaturas SHA-2. Para novas chaves, Ed25519 é a escolha preferida.

Como corrijo conexões SSH do macOS para Windows Server?

A implementação OpenSSH do Windows Server historicamente era insensível a maiúsculas para nomes de usuário. Após a atualização do macOS Tahoe 26.3, você precisa usar o caso exato que o Windows reconhece. Para contas de domínio, use DOMINIO\NomeUsuario ou [email protected]. Para contas locais, verifique o nome da conta no Gerenciador de Computadores. Atualize seu ~/.ssh/config de acordo:

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

Isso também afeta SFTP e SCP?

Sim. Tanto sftp quanto scp usam a mesma biblioteca de cliente SSH e estão sujeitos à mesma aplicação de sensibilidade a maiúsculas e remoção de DSA. Quaisquer clientes SFTP (como Cyberduck, Transmit ou FileZilla) que usam o binário SSH do sistema também serão afetados. Clientes SFTP com interface gráfica que incluem sua própria biblioteca SSH (como Cyberduck com sua própria compilação libssh2) podem não ser afetados, mas isso depende do aplicativo específico.

Conclusão

O macOS Tahoe 26.3 implementou mudanças SSH que quebraram fluxos de trabalho estabelecidos sem aviso adequado. A aplicação de nomes de usuário sensíveis a maiúsculas, a remoção completa do DSA e os avisos de troca de chaves pós-quântica requerem atenção, mas todos são diretos de resolver uma vez que você entende o que mudou.

As ações imediatas são:

Audite seu ~/.ssh/config para incompatibilidades de maiúsculas em diretivas User e remova quaisquer referências ssh-dss
Gere chaves Ed25519 para substituir quaisquer chaves DSA restantes
Implante as novas chaves em todos os servidores do seu inventário
Atualize scripts de automação e pipelines de CI/CD com maiúsculas corretas do nome de usuário e caminhos de chaves
Silencie ou resolva avisos pós-quânticos com base na sua postura de segurança

Essas mudanças, embora perturbadoras, empurram o ecossistema SSH do macOS em direção a padrões de segurança mais fortes. Ed25519 é mais rápido, mais seguro e produz chaves menores do que DSA. Nomes de usuário sensíveis a maiúsculas estão alinhados com a especificação do protocolo SSH. A troca de chaves pós-quântica protege contra ameaças futuras. A dor da migração é real, mas as melhorias de segurança são substantivas.

Se você está configurando um novo ambiente de desenvolvimento no macOS Tahoe, comece com nosso guia de configuração do desenvolvedor macOS Tahoe para ter tudo configurado corretamente desde o início. Para uma configuração de segurança mais ampla, nosso guia de segurança e privacidade do macOS Tahoe cobre todo o stack de segurança além do SSH.