Introdução
Neste laboratório, você aprenderá os fundamentos de como proteger o acesso remoto a um sistema Linux usando o protocolo Secure Shell (SSH). Você ganhará experiência prática com funcionalidades essenciais do SSH, incluindo a configuração de autenticação baseada em chaves para segurança aprimorada, a transferência segura de arquivos entre sistemas e a criação de túneis SSH para encaminhamento de portas.
Você começará configurando um contêiner Docker para simular um ambiente de servidor remoto, tornando o laboratório mais realista. Em seguida, instalará o cliente OpenSSH em sua máquina host e gerará um novo par de chaves RSA usando o utilitário ssh-keygen. Em seguida, configurará o servidor Docker para aceitar essa chave para autenticação, estabelecendo uma conexão segura e sem senha entre seu host e o servidor em contêiner. Finalmente, você praticará o uso do comando scp para transferências seguras de arquivos e do comando ssh -L para encaminhar uma porta local para um serviço remoto, criando efetivamente um túnel seguro.
Configurar Servidor SSH Docker e Gerar um Par de Chaves
Nesta etapa, você configurará um contêiner Docker para simular um servidor SSH remoto e gerará um par de chaves seguro em sua máquina host. Essa abordagem fornece um ambiente mais realista ao separar o cliente (seu host) do servidor (contêiner Docker).
Como o Docker e o cliente OpenSSH já estão instalados neste ambiente, você pode prosseguir diretamente para a configuração do servidor.
Primeiro, certifique-se de que o serviço Docker esteja em execução:
sudo systemctl start docker
sudo systemctl enable docker
Agora, vamos criar um contêiner Docker que atuará como nosso servidor SSH. Usaremos o Ubuntu como imagem base e o configuraremos com recursos de servidor SSH. Crie um Dockerfile:
cat > Dockerfile << 'EOF'
FROM ubuntu:22.04
## Instalar servidor OpenSSH e outras utilidades
RUN apt-get update && \
apt-get install -y openssh-server nginx sudo && \
apt-get clean && \
rm -rf /var/lib/apt/lists/*
## Criar um usuário para acesso SSH
RUN useradd -m -s /bin/bash sshuser && \
echo 'sshuser:password123' | chpasswd && \
usermod -aG sudo sshuser
## Configurar SSH
RUN mkdir /var/run/sshd && \
sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin no/' /etc/ssh/sshd_config && \
sed -i 's/#PasswordAuthentication yes/PasswordAuthentication yes/' /etc/ssh/sshd_config && \
sed -i 's/#PubkeyAuthentication yes/PubkeyAuthentication yes/' /etc/ssh/sshd_config
## Criar diretório SSH para o usuário
RUN mkdir -p /home/sshuser/.ssh && \
chown sshuser:sshuser /home/sshuser/.ssh && \
chmod 700 /home/sshuser/.ssh
## Expor porta SSH
EXPOSE 22 80
## Iniciar serviço SSH
CMD ["/usr/sbin/sshd", "-D"]
EOF
Construa a imagem Docker:
sudo docker build -t ssh-server .
Execute o contêiner Docker, mapeando a porta 2222 em seu host para a porta 22 no contêiner:
sudo docker run -d --name ssh-lab-server -p 2222:22 -p 8080:80 ssh-server
Verifique se o contêiner está em execução:
sudo docker ps
Você deverá ver uma saída mostrando o contêiner em execução:
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
... ssh-server "/usr/sbin/sshd -D" ... Up ... 0.0.0.0:2222->22/tcp, 0.0.0.0:8080->80/tcp ssh-lab-server
Em seguida, você gerará um par de chaves SSH. As chaves SSH fornecem uma maneira mais segura de fazer login em um servidor com SSH do que usar apenas uma senha. Um par de chaves consiste em uma chave privada, que deve ser mantida em segredo, e uma chave pública, que pode ser compartilhada.
Usaremos o comando ssh-keygen para criar um novo par de chaves. Especificaremos o tipo de chave como rsa e o tamanho da chave como 2048 bits para forte segurança. O sinalizador -f nos permite especificar um nome de arquivo para nossas chaves, o que ajuda a organizá-las. Nomearemos nossa chave como ~/.ssh/id_rsa_lab_ssh.
Execute o comando a seguir. Quando solicitado por uma senha (passphrase), simplesmente pressione Enter duas vezes para prosseguir sem uma. Para este laboratório, omitiremos a senha por simplicidade, mas em um cenário do mundo real, você deve sempre usar uma senha forte para proteger sua chave privada.
ssh-keygen -t rsa -b 2048 -f ~/.ssh/id_rsa_lab_ssh
O comando gerará o par de chaves e mostrará onde os arquivos são salvos.
Generating public/private rsa key pair.
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/labex/.ssh/id_rsa_lab_ssh
Your public key has been saved in /home/labex/.ssh/id_rsa_lab_ssh.pub
The key fingerprint is:
SHA256:... labex@...
The key's randomart image is:
+---[RSA 2048]----+
| .o*+.. |
| . =.o. . |
| . o o. . |
| o . . |
| . S |
| . . . |
| o . |
| o . |
| E . |
+----[SHA256]-----+
Para confirmar que os arquivos de chave foram criados, você pode listar o conteúdo do diretório ~/.ssh. Você deverá ver sua nova chave privada (id_rsa_lab_ssh) e chave pública (id_rsa_lab_ssh.pub).
ls -l ~/.ssh/id_rsa_lab_ssh*
A saída será semelhante a esta, mostrando os dois novos arquivos:
-rw------- 1 labex labex 1876 ... /home/labex/.ssh/id_rsa_lab_ssh
-rw-r--r-- 1 labex labex 401 ... /home/labex/.ssh/id_rsa_lab_ssh.pub
Você agora instalou com sucesso o servidor SSH e criou um par de chaves, que usará nas próximas etapas para configurar e testar a autenticação segura.
Configurar e Testar Autenticação Baseada em Chave SSH
Nesta etapa, você configurará o servidor SSH Docker para reconhecer sua chave pública, permitindo que você faça login sem senha. Este processo envolve copiar sua chave pública para o contêiner Docker e, em seguida, testar a conexão.
Para que o servidor SSH o autentique usando sua chave, sua chave pública deve ser colocada no arquivo ~/.ssh/authorized_keys no servidor. Como nosso servidor está em execução em um contêiner Docker, precisamos copiar a chave pública de sua máquina host para o contêiner.
Primeiro, copie sua chave pública para o contêiner Docker usando o comando docker cp:
sudo docker cp ~/.ssh/id_rsa_lab_ssh.pub ssh-lab-server:/home/sshuser/.ssh/authorized_keys
Em seguida, precisamos definir as permissões de arquivo corretas dentro do contêiner. O SSH é muito rigoroso em relação à segurança e se recusará a usar chaves se as permissões forem muito abertas. Execute o comando a seguir para definir as permissões adequadas:
sudo docker exec ssh-lab-server chown sshuser:sshuser /home/sshuser/.ssh/authorized_keys
sudo docker exec ssh-lab-server chmod 600 /home/sshuser/.ssh/authorized_keys
Com a chave pública adicionada e as permissões definidas, você está pronto para testar a autenticação baseada em chave. Você tentará fazer SSH no contêiner Docker usando a porta 2222 (que mapeamos para a porta 22 do contêiner) como o usuário sshuser, especificando a chave privada que você criou.
Use o comando ssh com o sinalizador -i para apontar para o seu arquivo de chave privada e -p para especificar a porta:
ssh -i ~/.ssh/id_rsa_lab_ssh -p 2222 sshuser@localhost
Como você está se conectando a um novo host pela primeira vez, pode ser solicitado a verificar a autenticidade do host. Digite yes e pressione Enter.
The authenticity of host '[localhost]:2222 ([127.0.0.1]:2222)' can't be established.
ED25519 key fingerprint is SHA256:....
This key is not known by any other names
Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
Warning: Permanently added '[localhost]:2222' (ED25519) to the list of known hosts.
Se tudo estiver configurado corretamente, você será logado imediatamente sem ser solicitado a digitar uma senha. Você verá uma mensagem de boas-vindas e seu prompt de comando mudará para indicar que você está dentro do contêiner Docker:
Welcome to Ubuntu 22.04.3 LTS (GNU/Linux 5.15.0-88-generic x86_64)
...
sshuser@containerid:~$
Para sair da sessão SSH e retornar ao prompt do terminal do seu host, basta digitar exit e pressionar Enter.
exit
O login bem-sucedido sem senha confirma que sua autenticação baseada em chave está funcionando corretamente entre seu host e o contêiner Docker. Este método é significativamente mais seguro do que a autenticação tradicional por senha.
Transferir Arquivos com Segurança Usando scp
Nesta etapa, você aprenderá a usar o Secure Copy Protocol (scp) para transferir arquivos com segurança entre hosts. O scp utiliza o protocolo SSH subjacente, o que significa que ele se beneficia dos mesmos mecanismos de criptografia e autenticação que você já configurou, incluindo a autenticação baseada em chave.
Primeiro, vamos criar um arquivo de exemplo em seu diretório de trabalho atual, ~/project, que podemos usar para a transferência. Chamaremos de source_file.txt.
echo "This is a test file for scp." > source_file.txt
Você pode verificar se o arquivo foi criado listando-o:
ls -l source_file.txt
A saída deverá mostrar seu arquivo recém-criado:
-rw-r--r-- 1 labex labex 29 ... source_file.txt
Agora, você usará o scp para copiar source_file.txt para o diretório /tmp no contêiner Docker, demonstrando a transferência segura de arquivos para um servidor remoto. A sintaxe básica para scp é scp -i [private_key] -P [port] [source_file] [user]@[host]:[destination_path].
Você usará o sinalizador -i para especificar sua chave privada, -P para especificar a porta 2222 (a porta SSH do nosso contêiner Docker) e transferirá o arquivo para a conta sshuser no contêiner:
scp -i ~/.ssh/id_rsa_lab_ssh -P 2222 source_file.txt sshuser@localhost:/tmp/destination_file.txt
Você verá uma saída indicando o progresso da transferência de arquivos, que deve ser instantânea para um arquivo pequeno.
source_file.txt 100% 29 6.7KB/s 00:00
Para confirmar que o arquivo foi copiado com sucesso, conecte-se ao contêiner Docker e liste o arquivo de destino:
sudo docker exec ssh-lab-server ls -l /tmp/destination_file.txt
A saída confirmará a existência e os detalhes do arquivo copiado:
-rw-r--r-- 1 sshuser sshuser 29 ... /tmp/destination_file.txt
Você também pode verificar se o conteúdo do arquivo foi transferido corretamente:
sudo docker exec ssh-lab-server cat /tmp/destination_file.txt
Isso deverá exibir:
This is a test file for scp.
Você agora transferiu com sucesso um arquivo usando scp, demonstrando uma maneira segura e prática de mover dados entre sistemas em uma rede.
Criar um Túnel SSH para Encaminhamento de Porta com ssh -L
Nesta etapa, você aprenderá uma das funcionalidades mais poderosas do SSH: tunneling, também conhecido como port forwarding (encaminhamento de porta). Isso permite que você encaminhe com segurança o tráfego de rede de uma porta em sua máquina local para uma porta em um servidor remoto, efetivamente encapsulando um protocolo não criptografado dentro de uma conexão SSH segura. Praticaremos o local port forwarding.
Para demonstrar isso, precisamos de um serviço em execução em uma porta à qual possamos nos conectar. Felizmente, nosso contêiner Docker já tem o Nginx instalado e configurado. Precisamos iniciar o serviço Nginx dentro do contêiner.
Primeiro, inicie o serviço Nginx dentro do contêiner Docker:
sudo docker exec ssh-lab-server service nginx start
Você pode verificar se o Nginx está em execução corretamente dentro do contêiner:
sudo docker exec ssh-lab-server service nginx status
A saída deverá mostrar o serviço como em execução:
* nginx is running
Agora, vamos criar o túnel SSH. Usaremos o comando ssh com o sinalizador -L, que significa local port forwarding. A sintaxe é ssh -L [LOCAL_PORT]:[DESTINATION_HOST]:[DESTINATION_PORT] [USER]@[SERVER].
Encaminharemos o tráfego da porta 9090 em nossa máquina local para a porta 80 dentro do contêiner Docker. O sinalizador -N informa ao SSH para não executar um comando remoto, o que é ideal apenas para encaminhar portas. Observe que usamos a porta 2222 para nos conectar ao serviço SSH do nosso contêiner Docker.
Execute este comando. Este comando ocupará seu terminal atual e não retornará um prompt. Você precisará abrir um novo terminal para testar o túnel.
ssh -i ~/.ssh/id_rsa_lab_ssh -N -L 9090:localhost:80 -p 2222 sshuser@localhost
Agora, abra um novo terminal clicando no ícone + na barra de guias do terminal. Neste novo terminal, você pode testar o túnel usando curl. Ao acessar localhost:9090, sua solicitação será tunelada com segurança via SSH para a porta 80 dentro do contêiner Docker.
curl http://localhost:9090
Você deverá ver o conteúdo HTML da página de boas-vindas padrão do Nginx, o que confirma que o túnel está funcionando.
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
body {
width: 35em;
margin: 0 auto;
font-family: Tahoma, Verdana, Arial, sans-serif;
}
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>
<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p>
<p><em>Thank you for using nginx.</em></p>
</body>
</html>
Você criou com sucesso um túnel seguro que encaminha o tráfego de sua máquina host para um serviço em execução dentro do contêiner Docker. Para fechar a conexão, retorne ao primeiro terminal (aquele que está executando o comando ssh) e pressione Ctrl+C. Você pode então fechar o segundo terminal.
Resumo
Neste laboratório, você aprendeu as habilidades essenciais para proteger o acesso remoto em um sistema Linux usando o protocolo Secure Shell (SSH). Os principais objetivos abordados incluem a configuração e teste da autenticação baseada em chave, a transferência segura de arquivos com scp e a criação de um túnel SSH para encaminhamento de porta.
Você começou preparando o ambiente, o que envolveu a atualização da lista de pacotes do sistema e a instalação dos pacotes openssh-server e openssh-client. Após verificar que o serviço SSH estava ativo, você gerou um par de chaves RSA seguro de 2048 bits usando o comando ssh-keygen. Esta etapa fundamental criou as chaves pública e privada necessárias para estabelecer conexões seguras e sem senha nas etapas subsequentes.
