# Desativar senha no SSH sem perder acesso ao servidor

A sequência de 7 passos para desligar PasswordAuthentication sem se trancar do lado de fora, incluindo as diretivas que continuam aceitando senha depois do "no".

> a sequência segura tem 7 passos e a regra central é não editar o sshd_config antes de provar a chave em uma segunda sessão. Autorize a chave, teste com ssh -v, aplique em /etc/ssh/sshd_config.d/, valide com sshd -t e sshd -T, use reload (não restart) e só então feche a sessão antiga.

João Rizzon · 2026-10-07 · Servidores

---

Desligar `PasswordAuthentication` é uma linha de configuração. O lockout acontece porque a linha foi aplicada antes de alguém provar que a chave funciona, ou porque a senha continuava entrando por outra diretiva e ninguém percebeu que a chave nunca tinha sido usada de fato.

A sequência abaixo é escrita para ser executada de cima para baixo, com uma sessão SSH aberta que você não fecha até o fim. Não há medição própria aqui: é comportamento documentado das diretivas do OpenSSH e do painel, mais os erros literais que cada etapa produz quando falha.

## A ordem de operações que evita o lockout

A regra é simples: nada toca o `sshd_config` enquanto a autenticação por chave não tiver sido comprovada em uma conexão nova.

- Gerar/registrar a chave pública no servidor e ajustar permissões.
- Abrir uma **segunda sessão** com `ssh -v` usando só a chave, com senha ainda ligada. Essa sessão fica aberta.
- Escrever o drop-in em `/etc/ssh/sshd_config.d/`.
- Validar a sintaxe com `sshd -t` e inspecionar a configuração efetiva com `sshd -T`.
- `systemctl reload sshd`.
- Abrir uma **terceira** sessão e confirmar que a chave entra e que a senha é recusada.
- Só então fechar a sessão antiga.

No cPanel/WHM existe ainda um interruptor próprio: o tweak **SSH Password Authorization**, em WHM » Security Center, que a [documentação oficial do cPanel](https://docs.cpanel.net/whm/security-center/ssh-password-authorization-tweak/) descreve como a interface para habilitar ou desabilitar a autenticação por senha do servidor SSH. Se você usa WHM, decida qual caminho será a fonte da verdade (o tweak ou o drop-in) e não misture os dois no mesmo dia, para não acabar depurando uma alteração que outro mecanismo reescreveu.

## Permissões, dono e contexto SELinux que fazem o sshd ignorar a authorized_keys

O `sshd` ignora `authorized_keys` silenciosamente quando as permissões estão largas. O cliente recebe `Permission denied (publickey)` e nada no terminal dele explica o motivo; a explicação está no log do servidor, com mensagem de modo de arquivo inseguro (`bad ownership or modes`).

No cliente:

```bash
ssh-keygen -t ed25519 -C "admin@estacao"
ssh-copy-id -i ~/.ssh/id_ed25519.pub usuario@servidor
```

No servidor, confirme dono e modo com o caminho explícito da home do usuário. Você está como root nessa sessão, e `~` aqui expandiria para `/root`, corrigindo o diretório errado e deixando o do usuário exatamente como estava:

```bash
chown -R usuario:usuario /home/usuario/.ssh
chmod 700 /home/usuario/.ssh
chmod 600 /home/usuario/.ssh/authorized_keys
```

| Caminho | Modo | Dono |
|---|---|---||
| `~` (home) | sem escrita para grupo/outros | usuário |
| `~/.ssh` | 700 | usuário |
| `~/.ssh/authorized_keys` | 600 | usuário |
| Chave privada no cliente | 600 | usuário |

Em distribuições com SELinux em enforcing (EL7/EL8/EL9 e derivados), um `~/.ssh` criado por processo fora do contexto esperado fica com rótulo errado e o `sshd` não lê o arquivo mesmo com modo 600. O sintoma é idêntico ao de permissão:

```bash
restorecon -Rv /home/usuario/.ssh
ls -lZ /home/usuario/.ssh
```

O rótulo esperado para o diretório e o arquivo é `ssh_home_t`. Vale a mesma ressalva do bloco anterior: use `/home/usuario/.ssh`, não `~/.ssh`, se estiver como root. Se depois do `restorecon` o problema persistir, verifique negações com `ausearch -m avc -ts recent`.

## Como provar que a chave funciona antes de desligar a senha

Esta é a etapa que quase ninguém faz direito. Testar com `ssh usuario@servidor` não prova nada enquanto a senha funciona: você pode ter digitado a senha sem reparar e concluído que a chave está ok.

Force o método e observe a negociação:

```bash
ssh -v -o PreferredAuthentications=publickey \
        -o PubkeyAuthentication=yes \
        -o IdentitiesOnly=yes \
        -i ~/.ssh/id_ed25519 usuario@servidor
```

O que ler na saída `-v`:

- `Offering public key: ... ED25519` seguido de `Server accepts key` indica que o servidor reconheceu a chave.
- `Authentications that can continue: publickey,password` logo antes de `Permission denied (publickey)` significa que a chave foi oferecida e recusada: o problema está no servidor (permissão, contexto, `AuthorizedKeysFile`, `AllowUsers`).
- Se o cliente nem oferece a chave, o problema é local: caminho errado, `IdentityFile` não configurado, agente sem a chave carregada.

No lado do servidor, acompanhe em paralelo:

```bash
journalctl -u sshd -f
# ou
tail -f /var/log/secure
```

Se quiser diagnóstico granular sem derrubar o serviço, suba uma instância de teste em outra porta e conecte-se a ela:

```bash
/usr/sbin/sshd -d -p 2222 -f /etc/ssh/sshd_config
ssh -p 2222 -v usuario@servidor
```

A instância em modo debug atende uma conexão e encerra. Lembre de liberar a porta no firewall só pelo tempo do teste.

## Aplicar via drop-in, não editando o arquivo principal

Em servidores com painel, o `/etc/ssh/sshd_config` é território disputado: atualizações do sistema e rotinas do painel podem reescrever ou substituir o arquivo, e sua alteração some sem aviso. Versões atuais do OpenSSH empacotadas nas distribuições trazem, no topo do `sshd_config`, uma linha `Include /etc/ssh/sshd_config.d/*.conf`. Confirme antes:

```bash
grep -n '^Include' /etc/ssh/sshd_config
```

Se a linha existir, escreva o drop-in:

```bash
cat > /etc/ssh/sshd_config.d/10-keys-only.conf <<'EOF'
PasswordAuthentication no
KbdInteractiveAuthentication no
ChallengeResponseAuthentication no
PubkeyAuthentication yes
EOF
```

No OpenSSH, a **primeira** ocorrência de uma diretiva vence. Por isso o drop-in precisa ser incluído antes das definições do arquivo principal, e por isso o nome do arquivo (a ordem lexicográfica dentro do diretório) importa quando há mais de um.

Se a linha `Include` não existir, não invente: edite o arquivo principal, guarde uma cópia (`cp /etc/ssh/sshd_config /root/sshd_config.bak`) e reaplique após updates.

## PasswordAuthentication no não basta: teclado-interativo ainda aceita senha

É aqui que sysadmin experiente se engana. `PasswordAuthentication no` desliga apenas o método `password` do protocolo. A senha pode continuar entrando por outro caminho.

| Diretiva | Efeito se ficar ligada | Ação |
|---|---|---||
| `KbdInteractiveAuthentication` | Aceita senha via teclado-interativo, inclusive via PAM | `no` |
| `ChallengeResponseAuthentication` | Nome antigo da anterior; ainda presente em configs legadas | `no` |
| `UsePAM` | Habilita a pilha PAM; combinada com teclado-interativo, permite senha | manter `yes`, mas com as duas acima em `no` |

Manter `UsePAM yes` costuma ser necessário para contabilidade de sessão, limites e módulos de 2FA. O que fecha a porta da senha são as duas primeiras linhas, não desligar o PAM.

Valide o resultado efetivo, não o que você escreveu:

```bash
sshd -t && sshd -T | grep -Ei 'passwordauthentication|kbdinteractive|challengeresponse|usepam|pubkeyauthentication|allowusers|authorizedkeysfile'
```

`sshd -T` imprime a configuração já resolvida, com includes e defaults aplicados. Se a saída mostrar `passwordauthentication yes` depois da sua edição, há uma definição anterior vencendo.

## Três causas diferentes para o mesmo Permission denied (publickey)

Três armadilhas de configuração que produzem exatamente o mesmo `Permission denied (publickey)`:

- **`AllowUsers` / `AllowGroups`**: se a lista não inclui o usuário cuja chave você acabou de instalar, ele não entra, com chave ou sem. Cheque na saída de `sshd -T`.
- **`AuthorizedKeysFile` fora do padrão**: alguns hardenings apontam para `/etc/ssh/authorized_keys/%u`. Você colocou a chave em `~/.ssh/authorized_keys` e o `sshd` sequer lê esse arquivo. O valor efetivo também aparece em `sshd -T`.
- **`Match` com escopo errado**: tudo abaixo de um bloco `Match` pertence a ele até o próximo `Match`. Uma diretiva solta no fim do arquivo, depois de um `Match`, não é global.

Usado de propósito, `Match` é a melhor válvula de emergência: permite manter senha para um usuário ou uma origem de confiança enquanto o resto do mundo só entra por chave.

```bash
cat >> /etc/ssh/sshd_config.d/10-keys-only.conf <<'EOF'

# exemplo fictício: ajuste usuário e prefixo à sua realidade
Match Address 203.0.113.0/24
    PasswordAuthentication yes
    KbdInteractiveAuthentication yes
EOF
```

O bloco `Match` precisa ficar no fim do arquivo. O prefixo acima é da faixa reservada para documentação, use o seu. Se o acesso de emergência vier de IP dinâmico, prefira `Match User breakglass` com uma conta dedicada, chave própria e shell restrito.

## Por que reload e não restart, e os dois testes finais

```bash
sshd -t && systemctl reload sshd
systemctl status sshd --no-pager
```

`reload` envia SIGHUP ao processo mestre: ele relê a configuração e passa a aplicá-la às conexões novas, enquanto as sessões já autenticadas seguem vivas. `restart` mata o processo, e se a nova configuração tiver erro o serviço não sobe, com você ainda conectado e sem forma de abrir outra sessão. Por isso o `sshd -t` encadeado com `&&`: sintaxe inválida interrompe antes do reload.

Com a sessão antiga intacta, abra uma nova e confirme os dois lados:

```bash
# deve entrar
ssh -o PreferredAuthentications=publickey -i ~/.ssh/id_ed25519 usuario@servidor

# deve falhar sem sequer pedir senha
ssh -o PreferredAuthentications=password,keyboard-interactive -o PubkeyAuthentication=no usuario@servidor
```

Os dois métodos precisam estar na lista. `password` e `keyboard-interactive` são métodos distintos do protocolo: com apenas `password` em `PreferredAuthentications`, o cliente nem tenta o método que a diretiva `KbdInteractiveAuthentication` controla, e o teste passaria limpo com teclado-interativo ainda ligado no servidor.

A conexão precisa retornar `Permission denied (publickey,...)` imediatamente, sem prompt. Se aparecer prompt de senha, teclado-interativo continua ligado em algum lugar. Volte ao `sshd -T`.

## O caminho de volta, decidido antes de precisar

Antes do primeiro reload, saiba qual é o seu acesso fora de banda. Em servidor dedicado ou VPS, costuma ser console serial, KVM over IP ou VNC pelo painel do provedor, e modo de recuperação com o disco montado em outro ambiente. Teste se você consegue abrir esse console **hoje**, com o SSH funcionando: descobrir que a credencial do KVM expirou durante o lockout é a pior ordem possível.

A reversão do drop-in é trivial por qualquer um desses canais:

```bash
mv /etc/ssh/sshd_config.d/10-keys-only.conf /root/10-keys-only.conf.off
sshd -t && systemctl reload sshd
```

Se o `sshd` não estiver rodando (restart com config quebrada), suba após corrigir:

```bash
sshd -t
systemctl start sshd
```

Em modo de recuperação, com o sistema montado em `/mnt`, o mesmo arquivo é removido em `/mnt/etc/ssh/sshd_config.d/` e o servidor volta ao boot normal.

No WHM, há ainda o caminho da interface: o tweak **SSH Password Authorization** documentado pelo cPanel reativa a autenticação por senha pelo painel, sem SSH. Vale conhecer o caminho na árvore de menus antes de precisar dele, porque na hora do aperto você vai estar procurando por ele em uma sessão de console lenta.

Por fim, documente no runbook qual arquivo foi criado, qual usuário tem chave e qual é o bloco `Match` de emergência. O lockout raramente acontece no dia da mudança; acontece seis meses depois, quando a pessoa que fez a alteração não está mais no plantão.

