---
title: "Como instalar e configurar SSH no Ubuntu com segurança"
description: "Aprende a instalar o OpenSSH no Ubuntu, gerar chaves Ed25519, desativar o acesso root e proteger o teu servidor contra ataques automáticos."
url: "https://www.alemasone.com/pt/configurar-ssh-ubuntu-seguranca/"
language: "pt"
published: 2024-12-02
updated: 2026-09-19
categories: ["Segurança E Privacidade"]
translations:
  it: "https://www.alemasone.com/it/configurare-ssh-ubuntu/"
  en: "https://www.alemasone.com/en/securely-install-configure-ssh-ubuntu/"
  es: "https://www.alemasone.com/es/instalar-configurar-ssh-ubuntu-seguro/"
  fr: "https://www.alemasone.com/fr/installer-configurer-ssh-ubuntu-securite/"
  de: "https://www.alemasone.com/de/ssh-ubuntu-sicher-installieren-konfigurieren/"
---

# Como instalar e configurar SSH no Ubuntu com segurança

Um servidor SSH acessível pela internet recebe tentativas de acesso automáticas poucos minutos após ser ligado. Duas configurações eliminam quase todo o risco: **acesso apenas com chaves** e **login de root desativado**. Leva cinco minutos, e devem ser feitas antes de qualquer outra coisa.

O SSH é o canal encriptado através do qual administras um computador Linux à distância: terminal, transferência de ficheiros, túnel para outros serviços. No Ubuntu Desktop o servidor SSH não vem instalado por defeito, enquanto nas imagens para servidores normalmente já está presente. Neste guia, vais instalá-lo, ligá-lo a partir do teu computador com uma chave e torná-lo seguro.

## Instalação

```bash
sudo apt update
sudo apt install openssh-server
```

O serviço arranca sozinho. Verifica o estado:

```bash
sudo systemctl status ssh
```

![Terminal Ubuntu com o resultado de systemctl status ssh e o serviço marcado como active running](systemctl-status-ssh-ubuntu.png "A linha a verificar é a que contém active (running)")

No Ubuntu 24.04 não te assustes se, antes da primeira ligação, o estado aparecer como *inactive* com a linha *TriggeredBy: ssh.socket*: a partir do Ubuntu 22.10, o SSH é iniciado pelo socket ao primeiro intento de ligação, e `sudo systemctl status ssh.socket` deve constar como ativo. Para desligar totalmente o acesso remoto, por exemplo durante uma manutenção, usa `sudo systemctl disable --now ssh.socket ssh`.

Se o firewall UFW estiver ativo, autoriza o SSH **antes** de fechares a sessão em que estás a trabalhar:

```bash
sudo ufw allow OpenSSH
sudo ufw enable
```

> **Não atives o UFW antes de teres permitido [OpenSSH](https://www.openssh.com/).** A ligação atual será fechada e ficarás trancado fora do sistema. Num servidor remoto ao qual não possas aceder fisicamente, este é o erro que custa mais caro.

De outro computador, ligas-te com:

```bash
ssh nomeutente@indirizzo-ip
```

O comando funciona da mesma forma no Linux, macOS e Windows 10 e 11, que já têm o cliente SSH instalado: basta abrir o Terminal do Windows ou PowerShell. Na primeira ligação, será solicitado que confirmes a impressão digital (*fingerprint*) do servidor: escreve `yes`.

## As chaves: como funcionam

Um par de chaves tem uma parte privada, que fica no teu computador e não deve ser dada a ninguém, e uma parte pública, que copias para o servidor. Quando te ligas, o servidor verifica se tens a chave privada correta, sem que nada de secreto passe pela rede.

É mais seguro do que uma palavra-passe porque uma chave não se adivinha: os ataques de força bruta, que tentam milhões de combinações, não servem para nada.

### Gerar o par de chaves

No teu computador, não no servidor:

```bash
ssh-keygen -t ed25519 -C "il-mio-portatile"
```

![Terminal com ssh-keygen -t ed25519: frase de acesso, caminho dos dois ficheiros e impressão digital da chave](ssh-keygen-ed25519-ubuntu.png "O comando cria dois ficheiros: a chave privada e a pública com extensão .pub")

Ed25519 é o algoritmo recomendado hoje em dia: chaves curtas, verificação rápida, segurança elevada. Usa RSA apenas se precisares de te ligar a sistemas antigos que não reconheçam Ed25519 e, nesse caso, com pelo menos 4096 bits.

Quando te pedir uma **frase de acesso** (*passphrase*), coloca-a: protege a chave se alguém meter as mãos no teu computador. Para não teres de a escrever sempre, o agente SSH trata disso, lembrando-a até ao fim da sessão.

### Copiar a chave pública para o servidor

```bash
ssh-copy-id nomeutente@indirizzo-ip
```

Pede a palavra-passe apenas uma vez e configura as permissões corretas. No Windows `ssh-copy-id` não existe: abre o ficheiro `C:\Users\<nome>\.ssh\id_ed25519.pub`, copia o seu conteúdo e cola-o no fim do ficheiro `~/.ssh/authorized_keys` no servidor.

**Testa imediatamente a ligação com a chave numa segunda janela, mantendo a primeira aberta.** Só quando funcionar é que passas para bloquear as palavras-passe.

## Tornar a configuração segura

As definições do servidor ficam em `/etc/ssh/sshd_config`. Nas versões recentes do Ubuntu é melhor não mexer nesse ficheiro e criar, em vez disso, um ficheiro próprio dentro de `/etc/ssh/sshd_config.d/`, que será lido adicionalmente:

```bash
sudo nano /etc/ssh/sshd_config.d/99-sicurezza.conf
```

Conteúdo recomendado:

```text
PermitRootLogin no
PasswordAuthentication no
KbdInteractiveAuthentication no
PubkeyAuthentication yes
X11Forwarding no
MaxAuthTries 3
```

O que faz cada linha:

| Definição | Efeito |
|--------------|---------|
| `PermitRootLogin no` | Ninguém pode entrar diretamente como root: entras com o teu utilizador e usas `sudo` |
| `PasswordAuthentication no` | Só se entra com as chaves, as palavras-passe são rejeitadas |
| `KbdInteractiveAuthentication no` | Fecha outra via que reabriria o acesso por palavra-passe |
| `MaxAuthTries 3` | Limita as tentativas para cada ligação |
| `X11Forwarding no` | Desativa o encaminhamento de interface gráfica, que quase ninguém utiliza |

Antes de aplicar, verifica se a sintaxe está correta:

```bash
sudo sshd -t
```

Se não imprimir nada, está tudo em ordem e podes recarregar o serviço:

```bash
sudo systemctl reload ssh
```

> **Mantém aberta a sessão atual** enquanto aplicas as alterações e testa a nova ligação através de outra janela. Se tiveres errado alguma coisa, ainda terás uma ligação ativa para corrigir o erro.

## Defender-se de ataques automáticos

**Alterar a porta** de 22 para um número alto não torna o servidor mais seguro, mas reduz imenso o ruído nos logs, porque quase todas as varreduras automáticas tentam apenas a porta padrão. Configura-se com `Port 2222` no teu ficheiro de configuração, lembrando-te de abrir a nova porta no firewall (`sudo ufw allow 2222/tcp`). A partir do Ubuntu 22.10 inclusive, incluindo o 24.04, após a modificação também são necessários `sudo systemctl daemon-reload` e `sudo systemctl restart ssh.socket`, caso contrário o servidor continuará a ouvir na porta 22.

**[Fail2ban](https://github.com/fail2ban/fail2ban)** bloqueia por algum tempo os endereços que erram várias vezes consecutivas:

```bash
sudo apt install fail2ban
```

Com a configuração predefinida já protege o SSH. Podes ver os endereços bloqueados com `sudo fail2ban-client status sshd`.

**Limitar os utilizadores que podem entrar** é simples e eficaz: com `AllowUsers nomeutente` na configuração, nenhum outro utilizador pode ligar-se, mesmo com credenciais válidas.

## O ficheiro de configuração do cliente

No computador de onde te ligas, o ficheiro `~/.ssh/config` evita que tenhas de memorizar endereços e portas:

```text
Host server-casa
    HostName 192.168.1.50
    User alessandro
    Port 2222
    IdentityFile ~/.ssh/id_ed25519
```

A partir desse altura, basta usares o `ssh server-casa`. O nome também funciona com `scp` e `rsync`.

## Transferir ficheiros

```bash
scp documento.pdf server-casa:/home/alessandro/
```

Para pastas inteiras e cópias que repetes frequentemente, usa o `rsync`, que transfere apenas o que foi alterado:

```bash
rsync -avz --progress cartella/ server-casa:/percorso/di/destinazione/
```

Se preferires um programa com interface gráfica, o FileZilla e o WinSCP ligam-se via SFTP usando as mesmas credenciais e a mesma chave.

## Perguntas frequentes

### Se desativar as passwords e perder a chave privada, fico de fora?

Sim, e esse é um risco que deves gerir antecipadamente. Duas precauções: adiciona ao servidor as chaves públicas de todos os dispositivos a partir dos quais te vais ligar, e guarda uma cópia da chave privada num local seguro, por exemplo, no teu gestor de passwords. Se o servidor for uma máquina virtual num provider, normalmente também existe um console de emergência no painel web.

### Ed25519 ou RSA?

Ed25519 sempre que puderes: é mais moderno, as chaves são mais curtas e a verificação é mais rápida. RSA a 4096 bits apenas para sistemas antigos que não suportem Ed25519.

### Mudar a porta serve de alguma coisa?

Não aumenta a segurança, porque um scan direcionado acaba por encontrar o serviço de qualquer forma. No entanto, reduz drasticamente as tentativas automáticas e torna os logs mais legíveis: quando aparece uma tentativa, sabes que merece atenção.

### Como me ligo se o endereço IP de casa mudar?

Com um serviço de DNS dinâmico, que associa um nome fixo ao teu endereço e o atualiza automaticamente quando este muda. Muitos routers já suportam isto nas definições. Em alternativa, uma [VPN como a Tailscale](/pt/melhores-solucoes-vpn-self-hosted/) permite-te aceder ao servidor sem precisares de abrir portas no router.

### O que significa o aviso de que a chave do host mudou?

Significa que a identidade do servidor não corresponde àquela que foi guardada na primeira ligação. Pode ser normal, se tiveres reinstalado o sistema ou mudado de máquina, ou pode ser um sinal de alguém a tentar intercetar a ligação. Antes de continuares, tenta perceber o motivo; só depois removes a entrada antiga com `ssh-keygen -R indirizzo-ip`.