Como Reforçar a Segurança do SSH no OpenSSH - Guia Prático

Introdução

Neste laboratório, você aprenderá técnicas essenciais para aprimorar a segurança do SSH no OpenSSH através da autenticação por chave e do endurecimento da configuração. Você praticará a substituição da autenticação por senha por pares de chaves seguras, a desativação do login como root e a modificação das portas padrão para mitigar ataques de força bruta.

Os exercícios práticos o guiarão através da geração de chaves criptográficas, da configuração de permissões de arquivo adequadas e do teste da sua configuração SSH segura. Você também aprenderá comandos-chave para gerenciar os serviços SSH e verificar suas configurações de segurança.

Instalar OpenSSH

Nesta etapa, você instalará o pacote do servidor OpenSSH na sua VM LabEx. OpenSSH (Open Secure Shell) é uma implementação de código aberto e gratuita do protocolo SSH que fornece comunicações seguras e criptografadas entre dois hosts não confiáveis através de uma rede insegura. É a ferramenta padrão para administração remota de servidores e transferências seguras de arquivos.

Antes de começarmos, é importante entender que o SSH funciona em um modelo cliente-servidor. O servidor (que estamos instalando agora) escuta por conexões de entrada, enquanto os clientes (como o terminal na sua máquina local) se conectam a ele. Toda a comunicação é criptografada, protegendo suas credenciais e dados.

Como a VM LabEx usa contêineres Docker onde systemctl não está disponível (os contêineres Docker normalmente executam processos únicos em vez de sistemas operacionais completos), usaremos o comando service para gerenciar o daemon SSH. Esta é uma alternativa mais simples ao systemctl que funciona bem em ambientes conteinerizados.

Siga estas etapas para instalar o OpenSSH:

Primeiro, atualize sua lista de pacotes para garantir que você obtenha a versão mais recente. Isso busca as informações mais recentes do pacote dos repositórios do Ubuntu:
```
sudo apt update
```
Instale o pacote do servidor OpenSSH. A flag -y confirma automaticamente quaisquer prompts durante a instalação:
```
sudo apt install -y openssh-server
```
Após a instalação, verifique se o serviço SSH está em execução. O comando status mostra se o serviço está ativo e ouvindo por conexões:
```
service ssh status
```
Você deve ver uma saída indicando que o serviço está ativo (em execução). Se não estiver em execução, vamos iniciá-lo na próxima etapa.
Se o serviço não estiver em execução (o que mostraria "inativo" na saída do status), inicie-o manualmente:
```
service ssh start
```
Verifique se o SSH está ouvindo na porta padrão (22). O comando netstat mostra as conexões de rede e as portas de escuta, enquanto grep filtra as entradas relacionadas ao SSH:
```
sudo netstat -tulnp | grep sshd
```
Você deve ver uma saída semelhante a esta, mostrando que o SSH está ouvindo em todas as interfaces de rede (0.0.0.0) na porta 22:
```
tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN      -
```

Configurar Autenticação por Chave

Nesta etapa, você configurará a autenticação SSH baseada em chave, que oferece maior segurança do que a autenticação por senha tradicional. Ao contrário das senhas que podem ser adivinhadas ou atacadas por força bruta, a autenticação por chave usa um par de chaves criptográficas - uma privada (mantida em segredo) e uma pública (compartilhada com os servidores).

Quando você se conecta a um servidor SSH, ele usa algoritmos matemáticos para verificar se você possui a chave privada que corresponde à chave pública que ele tem em arquivo. Este método é mais seguro e mais conveniente depois de configurado.

Vamos criar e configurar essas chaves passo a passo:

Primeiro, vamos gerar um novo par de chaves SSH. Este comando cria dois arquivos no seu diretório ~/.ssh:
```
ssh-keygen -t rsa -b 4096 -f ~/.ssh/labex_key -N ""
```
- -t rsa especifica o tipo de chave (algoritmo RSA)
- -b 4096 cria uma chave forte de 4096 bits
- -f define o nome do arquivo para o seu par de chaves
- -N "" significa sem senha (para simplificação do laboratório)
Agora você terá:
- Chave privada: ~/.ssh/labex_key (nunca compartilhe isso!)
- Chave pública: ~/.ssh/labex_key.pub (esta é compartilhada com os servidores)
Permissões de arquivo adequadas são cruciais para a segurança do SSH. Estes comandos garantem que apenas você pode acessar suas chaves:
```
chmod 700 ~/.ssh
chmod 600 ~/.ssh/labex_key
chmod 644 ~/.ssh/labex_key.pub
```
Agora, autorizaremos sua chave adicionando a chave pública ao arquivo especial authorized_keys que o SSH verifica:
```
cat ~/.ssh/labex_key.pub >> ~/.ssh/authorized_keys
chmod 600 ~/.ssh/authorized_keys
```
Em seguida, configuraremos o próprio servidor SSH. Edite o arquivo de configuração principal:
```
sudo nano /etc/ssh/sshd_config
```
Encontre e modifique estas configurações importantes:
```
PubkeyAuthentication yes
PasswordAuthentication no
```
Isso diz ao SSH para:
- Permitir a autenticação por chave (habilitada por padrão, mas bom confirmar)
- Desabilitar logins por senha (forçando apenas o acesso baseado em chave)
Após alterar a configuração, sempre reinicie o serviço SSH:
```
service ssh restart
```
Finalmente, vamos verificar se tudo funciona. Tente se conectar à sua própria máquina (localhost) usando sua nova chave:
```
ssh -i ~/.ssh/labex_key localhost
```
A flag -i especifica qual chave privada usar. Se for bem-sucedido, você fará login imediatamente sem qualquer solicitação de senha - isso confirma que a autenticação por chave está funcionando corretamente.

Nesta etapa, desabilitaremos o login root direto através do SSH. Isso é importante porque a conta root tem privilégios completos no sistema, tornando-a um alvo principal para hackers. Ao desabilitar o login root, forçamos os invasores a adivinhar um nome de usuário e senha, tornando os ataques de força bruta muito mais difíceis.

Quando você precisar de privilégios root após esta alteração, primeiro fará login com uma conta de usuário regular e, em seguida, usará sudo para tarefas administrativas. Isso cria uma camada de segurança extra, pois os invasores precisariam comprometer duas contas.

Vamos modificar a configuração do SSH:

Primeiro, abra o arquivo de configuração principal do SSH com um editor de texto. Usaremos o nano aqui, mas você pode usar qualquer editor com o qual se sinta confortável:
```
sudo nano /etc/ssh/sshd_config
```
Procure a linha que diz PermitRootLogin (geralmente por volta da linha 32). Se você não conseguir encontrá-la, precisará adicioná-la. Altere ou adicione esta linha para:
```
PermitRootLogin no
```
Enquanto editamos este arquivo, vamos definir alguns parâmetros de segurança adicionais que funcionam bem com esta alteração:
```
StrictModes yes
MaxAuthTries 3
LoginGraceTime 60
```
- StrictModes verifica as permissões de arquivo para segurança
- MaxAuthTries limita as tentativas de login com falha
- LoginGraceTime define quanto tempo um login pode levar
Salve suas alterações no nano pressionando:
- Ctrl+O para escrever
- Enter para confirmar
- Ctrl+X para sair
Para que as alterações entrem em vigor, reinicie o serviço SSH:
```
service ssh restart
```
Vamos testar se nossas alterações funcionaram tentando fazer SSH como root (isso deve falhar):
```
ssh root@localhost
```
Você deve ver um erro como "Permission denied (publickey)", o que significa que nossa medida de segurança está funcionando corretamente. De agora em diante, você precisará usar uma conta de usuário regular para fazer login.

Alterar a Porta Padrão

Nesta etapa, modificaremos a porta SSH padrão de 22 para uma porta personalizada (2222 em nosso exemplo). Esta é uma medida de segurança importante porque muitos bots automatizados e invasores procuram servidores SSH na porta padrão 22. Ao mudar para uma porta não padrão, tornamos nosso servidor menos visível para essas verificações automatizadas.

Antes de fazer qualquer alteração, vamos primeiro verificar a configuração atual da porta SSH. Isso nos ajuda a entender a configuração existente:

sudo grep -i port /etc/ssh/sshd_config

Você normalmente verá #Port 22 na saída. O símbolo # significa que esta linha está comentada, então o SSH está atualmente usando a porta padrão 22.

Agora, editaremos o arquivo de configuração do SSH. Usaremos o editor de texto nano, que é amigável para iniciantes:

sudo nano /etc/ssh/sshd_config

Dentro do arquivo, procure a linha que contém #Port 22. Precisamos fazer duas alterações aqui:

Remova o # para descomentar a linha (isso ativa a configuração)
Altere o número da porta de 22 para 2222

A linha modificada deve ser assim:

Port 2222

Depois de fazer esta alteração, salve o arquivo no nano pressionando:

Ctrl+O (para escrever o arquivo)
Enter (para confirmar o nome do arquivo)
Ctrl+X (para sair do editor)

Para que as alterações entrem em vigor, precisamos reiniciar o serviço SSH:

service ssh restart

Vamos verificar se o SSH agora está ouvindo em nossa nova porta (2222) em vez da porta padrão:

sudo netstat -tulnp | grep ssh

A saída deve mostrar o SSH ouvindo na porta 2222. Se você ainda vir a porta 22, verifique novamente as alterações no seu arquivo de configuração.

Finalmente, teste a nova configuração conectando-se ao SSH usando a porta personalizada. Observe que precisamos especificar a porta com a flag -p agora:

ssh -p 2222 -i ~/.ssh/labex_key localhost

Após conectar com sucesso, você pode sair da sessão SSH pressionando Ctrl+D. Lembre-se de que, a partir de agora, você sempre precisará especificar esta porta personalizada ao se conectar ao seu servidor SSH.

Testar a Configuração Reforçada

Nesta etapa final, verificaremos todas as medidas de reforço de segurança que você implementou. Testar é crucial para garantir que seu servidor SSH esteja configurado e seguro corretamente. Examinaremos as configurações do lado do servidor e as tentativas de conexão do lado do cliente.

Vamos começar verificando a configuração atual do SSH em seu servidor. Isso confirma que as alterações que você fez anteriormente estão ativas:

Primeiro, verifique todas as configurações atuais do SSH:
```
sudo sshd -T | grep -E 'port|permitrootlogin|passwordauthentication|pubkeyauthentication'
```
O comando sshd -T exibe a configuração real em tempo de execução. Estamos filtrando por parâmetros de segurança importantes. Você deve ver:
```
port 2222
permitrootlogin no
passwordauthentication no
pubkeyauthentication yes
```
Esta saída confirma que o SSH está sendo executado na porta 2222, o login root está desabilitado, a autenticação por senha está desativada e a autenticação por chave pública está habilitada.

Agora, vamos testar as conexões da perspectiva do cliente:

Teste a conexão bem-sucedida com autenticação por chave:
```
ssh -p 2222 -i ~/.ssh/labex_key localhost "echo 'Key auth successful'"
```
Isso tenta se conectar usando sua chave privada (a flag -i especifica o arquivo de chave). O comando executa um simples echo no servidor se for bem-sucedido. Você deve ver:
```
Key auth successful
```
Teste a tentativa de login root com falha:
```
ssh -p 2222 root@localhost 2>&1 | grep -i "permission denied"
```
Isso tenta fazer login como root, o que deve falhar porque desabilitamos o login root. O comando filtra a mensagem de erro esperada.
Teste a tentativa de autenticação por senha com falha:
```
ssh -p 2222 -o PreferredAuthentications=password -o PubkeyAuthentication=no localhost 2>&1 | grep -i "permission denied"
```
Aqui, forçamos a autenticação por senha (desabilitada em nossa configuração) para verificar se ela está devidamente bloqueada. As opções desabilitam explicitamente a autenticação por chave.

Finalmente, vamos verificar o status da rede do servidor:

Verifique as conexões SSH ativas:
```
sudo netstat -tulnp | grep 2222
```
Isso mostra todas as portas de escuta, filtradas para nossa porta SSH personalizada (2222). Você deve ver sshd listado como escutando nesta porta.
Verifique o status do serviço SSH:
```
service ssh status
```
Confirma que o serviço SSH está sendo executado corretamente. A saída deve indicar que o serviço está ativo.

Resumo

Neste laboratório, você aprendeu a aprimorar a segurança do SSH no OpenSSH por meio de configurações práticas. Os exercícios cobriram a instalação do servidor OpenSSH, a verificação de seu status e a implementação da autenticação baseada em chave com configurações de permissão adequadas.

Você também explorou técnicas críticas de reforço de segurança, incluindo a desativação do login root e a alteração da porta SSH padrão. Essas medidas reduzem efetivamente a vulnerabilidade a ataques de força bruta e varreduras automatizadas, mantendo a funcionalidade do sistema.

Reforçar a Segurança do SSH no OpenSSH