# Dar acesso root ao prestador sem senha, do cadastro à revogação

Cadastrar a chave do prestador no WHM, auditar as chaves órfãs que já estão no authorized_keys e revogar no fim do contrato com prova escrita. Com checklist para padronizar em toda a carteira.

> use chave pública em vez de senha: o prestador manda só o arquivo `.pub`, você importa e autoriza em Manage root's SSH Keys no WHM, registra o fingerprint no inventário e, no último dia, desautoriza. A prova é o `Permission denied (publickey)` que ele passa a ver.

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

---

## O acordo técnico: ninguém digita senha, nem você

Quando a agência administra o servidor (VPS ou dedicado com WHM) e precisa colocar um prestador para dentro, a saída errada é criar uma senha de root e mandar no chat. Senha vaza, fica em histórico de conversa, não tem dono e não tem data de validade. A saída certa é chave pública: o prestador gera um par de chaves na máquina dele, manda só a parte pública, e você cola essa chave no servidor.

Três propriedades que a senha não tem:

- **A chave privada nunca sai da máquina do prestador.** Você nunca tem acesso ao segredo dele, e ele nunca tem acesso ao seu.
- **Cada pessoa tem uma linha própria** no `authorized_keys`. Revogar um prestador não derruba os outros.
- **A revogação corta novas conexões e é verificável.** Removeu a linha, a próxima tentativa é recusada com `Permission denied (publickey)`. Sessão SSH já estabelecida não cai sozinha: ela continua viva até o prestador desconectar ou você derrubar o processo. Por isso o encerramento só está fechado depois de conferir quem está conectado naquele momento.

O WHM tem tela dedicada para isso em **Home » Security Center » Manage root's SSH Keys**, e a [documentação oficial do cPanel](https://docs.cpanel.net/whm/security-center/manage-root-ssh-keys/) descreve as ações disponíveis: gerar par de chaves, importar chave, autorizar e desautorizar chave pública.

## Peça a chave pública sem parecer burocracia

O atrito costuma estar aqui: você pede "a chave pública" e o prestador some por dois dias. Resolve com uma mensagem que já contém o comando. Frase pronta, pode copiar:

> **** Para te liberar no servidor eu não uso senha, uso chave SSH, assim seu acesso é individual e some no último dia do contrato sem mexer no de mais ninguém. Me manda sua chave **pública** (o arquivo que termina em `.pub`). Se ainda não tiver uma, roda `ssh-keygen -t ed25519 -C "seu-email"` e depois `cat ~/.ssh/id_ed25519.pub`, e me cola o conteúdo aqui. A chave privada fica com você, eu não preciso dela e não quero.

A linha que você deve receber começa com `ssh-ed25519` ou `ssh-rsa`, vem em uma única linha e termina com o comentário do autor. Exemplo fictício, só para você reconhecer o formato:

```
ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIEXEMPLOEXEMPLOEXEMPLOEXEMPLOEXEMPLO dev@agencia-exemplo
```

Se o que chegou começa com `-----BEGIN OPENSSH PRIVATE KEY-----`, o prestador mandou a chave privada por engano. Não use. Avise, peça para ele gerar outro par e descartar esse, porque a chave privada trafegou por um canal que você não controla.

## Cadastrar a chave no WHM, passo a passo

### Onde fica a tela Manage root's SSH Keys

No WHM, vá em **Home » Security Center » Manage root's SSH Keys**. É a tela que o cPanel documenta para administrar as chaves do usuário root do servidor.

### Importar só a chave pública, com nome que identifique o contrato

Use a ação de importar chave. A documentação do cPanel prevê a importação tanto de chave pública quanto de chave privada; aqui você importa **só a pública**, e dá a ela um nome que identifique a pessoa e o contrato. Nome de arquivo serve de etiqueta: `prestador_joao_2026` diz mais do que `id_rsa2`.

### Autorizar, porque importar sozinho não libera acesso

Importar não libera acesso. A chave só passa a valer quando você usa a ação de autorizar, que é o que escreve a linha no `authorized_keys` do root. Na mesma tela o cPanel mostra o estado de cada chave e permite desautorizar.

### Validar com ssh -v enquanto o prestador ainda está online

Peça para ele conectar e te mandar a saída. Validação do lado dele:

```
ssh -v root@servidor.exemplo.com.br
```

O `-v` mostra qual chave foi oferecida e aceita. Se entrar sem pedir senha, acabou. Se pedir senha, a chave não está autorizada ou as permissões de diretório no servidor estão erradas.

### Desligar o login por senha, de onde vem a prova da revogação

De nada adianta distribuir chave e manter login por senha habilitado para o root. No `sshd_config`, as diretivas que interessam são `PermitRootLogin` e `PasswordAuthentication`. A combinação usual em servidor de produção é `PermitRootLogin prohibit-password` com `PasswordAuthentication no`. Antes de recarregar o serviço, valide a sintaxe e **mantenha a sessão atual aberta** em outra janela:

```
sshd -t && systemctl reload sshd
```

Se o `sshd -t` reclamar, ele não recarrega. Essa é a rede de segurança que evita se trancar do lado de fora.

Esse passo não é cosmético: com `PasswordAuthentication yes` ainda ativo, a recusa no fim do contrato não vem limpa, porque o servidor continua oferecendo senha como método alternativo. A prova escrita do encerramento depende desta configuração.

## Chaves no authorized_keys que ninguém da equipe reconhece

Essa é a parte que quase ninguém faz. Em servidor com mais de um ano de vida, o `authorized_keys` do root costuma ter linha de ex-prestador, de ferramenta de deploy desativada e de migração que alguém fez em 2021.

O arquivo fica em `/root/.ssh/authorized_keys` e cada linha é uma chave. Para listar com impressão digital, tipo e comentário:

```
ssh-keygen -lf /root/.ssh/authorized_keys
```

A saída traz, por linha: tamanho em bits, fingerprint, comentário e tipo da chave. O comentário é o texto no fim da linha (normalmente `usuario@maquina`) e é só um rótulo: **não é identidade, qualquer um pode editar**. Trate como pista, não como prova.

Para numerar as linhas e falar com os outros sócios sobre "a linha 3":

```
cat -n /root/.ssh/authorized_keys
```

Monte a planilha de inventário assim, um servidor por aba:

| Linha | Fingerprint (início) | Comentário | Dono identificado | Contrato | Ação |
|---|---|---|---|---|---||
| 1 | SHA256:7bQ… | `dev@agencia-exemplo` | João (prestador) | até 30/11 | manter até a data |
| 2 | SHA256:kR2… | `root@deploy01` | ninguém reconhece | sem contrato | remover |
| 3 | SHA256:9xZ… | `backup@ferramenta` | script de backup | ativo | manter e documentar |

Regra de decisão para a chave órfã: se ninguém da equipe assume a chave em 48 horas, ela sai. O risco de remover uma chave legítima é um prestador reclamar e você devolver em dois minutos. O risco de manter uma chave órfã é acesso root permanente de alguém desconhecido.

Antes de editar, guarde uma cópia com data:

```
cp -a /root/.ssh/authorized_keys /root/.ssh/authorized_keys.bak-$(date +%F)
```

E confira as permissões, porque o `sshd` ignora chave em diretório frouxo:

```
chmod 700 /root/.ssh
chmod 600 /root/.ssh/authorized_keys
```

## Revogar no último dia e provar que a conexão foi recusada

Revogar pela interface é o caminho normal: na mesma tela de **Manage root's SSH Keys** do WHM existe a ação de desautorizar a chave pública, que é a inversa de autorizar. Depois de desautorizar, confirme no arquivo que a linha não está mais lá:

```
grep -c 'dev@agencia-exemplo' /root/.ssh/authorized_keys
```

Saída `0` significa que nenhuma linha com aquele comentário permanece. Confira também pelo fingerprint que você anotou no inventário, com o `ssh-keygen -lf` de novo, porque o comentário pode ter sido alterado.

A prova que fecha o ciclo vem do lado do prestador: peça para ele tentar conectar e te mandar a saída, no mesmo formato de sempre:

```
ssh -o BatchMode=yes root@servidor.exemplo.com.br
```

O `BatchMode=yes` impede o cliente de cair em prompt interativo, então a tentativa falha de imediato em vez de ficar pedindo senha. A resposta esperada é:

```
Permission denied (publickey).
```

Essa linha é o seu comprovante, e ela só sai nesse formato se o login por senha estiver desligado. Se o prestador não responder, dá para produzir a mesma recusa da sua máquina, desde que você use uma chave que **não** esteja no `authorized_keys` do root (gere um par descartável com `ssh-keygen -t ed25519 -f /tmp/chave_teste` e nunca autorize essa chave):

```
ssh -i /tmp/chave_teste -o IdentitiesOnly=yes -o BatchMode=yes root@servidor.exemplo.com.br
```

O `IdentitiesOnly=yes` impede o cliente de oferecer a sua chave de administrador, que continua autorizada e te deixaria entrar normalmente. Esse teste prova que o servidor recusa quem não tem chave autorizada, não que a chave específica do prestador foi removida: a chave privada dele está com ele, você não tem como reproduzi-la. A verificação de que a linha dele saiu é a do fingerprint, no passo anterior. Com `PasswordAuthentication yes` no `sshd_config`, o servidor ainda anuncia a senha como método válido e a resposta vira `Permission denied (publickey,password)`, ou o cliente cai em prompt de senha quando você não usa `BatchMode=yes`. Nesse caso a mensagem prova que aquela chave não vale mais, mas não prova que o acesso por senha está fechado. Se o passo 5 não foi feito, faça antes de capturar a evidência. Guarde junto do registro do contrato, com data e hora.

Antes de declarar o acesso encerrado, confira se ele não está conectado neste exato momento. Linha removida não expulsa quem já entrou:

```
who
ss -tnp state established '( sport = :22 )'
```

Se aparecer sessão do prestador, derrube o processo correspondente (`kill` no PID que o `ss` mostra) e repita o `who` para confirmar que não voltou.

**Não esqueça do resto.** Chave SSH revogada não revoga o que o prestador criou enquanto estava dentro. No mesmo dia, verifique: usuários de sistema criados por ele, chaves adicionadas em outros usuários além do root, entradas de `crontab` (`crontab -l` e `crontab -l -u usuario`), e acessos ao painel, ao WordPress e ao FTP dos sites.

## Checklist reutilizável para todos os servidores da carteira

Salve como template e duplique por servidor. É o que transforma isso em processo em vez de favor.

**Abertura de acesso**

- Pedir a chave pública com a mensagem pronta (nunca aceitar chave privada).
- Conferir se a linha recebida começa com `ssh-ed25519` ou `ssh-rsa`.
- Importar no WHM com nome que identifique pessoa e contrato.
- Autorizar a chave.
- Registrar no inventário: fingerprint, comentário, dono, data de início e **data de término já preenchida**.
- Validar com `ssh -v` do lado do prestador, com ele online.
- Confirmar `PermitRootLogin prohibit-password` e `PasswordAuthentication no`, validando com `sshd -t` antes do reload.

**Auditoria trimestral (todos os servidores no mesmo dia)**

- `ssh-keygen -lf /root/.ssh/authorized_keys` e comparar com o inventário.
- Marcar toda chave sem dono identificado.
- Dar 48 horas para alguém assumir. Sem resposta, remover.
- Repetir para usuários não-root que tenham `~/.ssh/authorized_keys`.
- Conferir permissões `700` no diretório e `600` no arquivo.

**Encerramento de contrato**

- Backup datado do `authorized_keys`.
- Desautorizar a chave no WHM.
- Verificar por fingerprint que a linha saiu.
- Pedir ao prestador a tentativa de conexão com `-o BatchMode=yes` e capturar o `Permission denied (publickey)`, com login por senha já desligado. Sem resposta dele, repetir da sua máquina com uma chave descartável e `-o IdentitiesOnly=yes`.
- Conferir sessões ativas com `who` e `ss -tnp state established '( sport = :22 )'` e derrubar as que forem do prestador.
- Revisar usuários, crontabs, acessos de painel, WordPress e FTP.
- Anexar a prova ao registro do contrato.

## Onde esse processo costuma quebrar

**O prestador manda a chave de outra máquina.** Ele trabalha no notebook e no desktop. Duas máquinas, duas chaves, duas linhas no inventário, duas revogações. Deixe isso claro na abertura.

**Alguém adiciona chave direto no arquivo e não registra.** Acontece em equipe de três pessoas ou mais. A auditoria trimestral existe exatamente para isso: a diferença entre o `ssh-keygen -lf` e a planilha é a lista de coisas que ninguém anotou.

**Reinstalação ou migração do servidor.** Ao mover para outra máquina, a tentação é copiar o `authorized_keys` inteiro. Não copie: reconstrua a partir do inventário, só com as chaves que têm dono e contrato vigente. Migração é a melhor oportunidade do ano para zerar chave órfã.

**O cliente final pergunta por que o acesso é assim.** Frase pronta para o e-mail: "o acesso do prestador ao seu servidor é individual e por chave criptográfica, não por senha compartilhada. Isso significa que ninguém mais usa o mesmo acesso, e que no último dia de contrato a conexão dele passa a ser recusada pelo servidor, com registro". Resolve a conversa sem explicar protocolo.

Uma observação honesta sobre este conteúdo: os procedimentos e as telas descritos aqui vêm da [documentação oficial do cPanel para Manage root's SSH Keys](https://docs.cpanel.net/whm/security-center/manage-root-ssh-keys/) e do manual do `sshd` e do `ssh-keygen` do OpenSSH. Não há medição própria neste tema, porque não há o que medir: o que existe é processo, e processo se julga por ser repetível em todos os servidores da carteira, não por latência.

