SSH! Contato imeditato de primeiro grau…

Neste artigo vamos conhecer um pouco do SSH (Secure SHell) e como utilizar o básico dele no nosso dia a dia, e depois se quiser colocar em prática, de forma segura e gratuita, poderá utilizar este ambiente interativo.

Se quiser saber o que estou escrevendo ou estudando visite o meu Diário de Bordo e veja as novidades.

O que é e como funciona?

O SSH foi desenvolvido com o intuito de habilitar um canal de comunicação segura entre 2 equipamentos, um que faz o papel de cliente SSH (origem da conexão) e outro que faz o papel de servidor SSH (destino da conexão), utilizando criptografia de chave pública ou criptografia assimétrica.

Fonte.: https://www.hostinger.com.br/tutoriais/como-funciona-o-ssh

Abaixo vemos os pacotes OpenSSH disponíveis no Ubuntu 20.04.

$ sudo apt-cache search openssh | grep -e ^openssh
openssh-client - cliente secure shell (SSH), para acesso seguro a máquinas remotas
openssh-server - secure shell (SSH) server, for secure access from remote machines
openssh-sftp-server - secure shell (SSH) sftp server module, for SFTP access from remote machines
openssh-client-ssh1 - secure shell (SSH) client for legacy SSH1 protocol
openssh-known-hosts - download, filter and merge known_hosts for OpenSSH
openssh-tests - OpenSSH regression tests

Para ver quais sistemas já integram o OpenSSH à sua instalação padrão, consulte esta página.

Uso simples e direto

Para logar no computador remoto (o que faz o papel de servidor SSH) com o mesmo nome de usuário logado localmente (a partir do computador que faz o papel de cliente SSH), simplesmente use:

$ ssh nome-do-computador.exemplo.com.br

Porém, se for utilizar outro usuário para logar no computador remoto, informe-o antes do nome do computador, usando o ‘@’ que podemos traduzir para ‘em’ ou ‘no’ neste caso, dessa forma.

$ ssh nome-do-usuario@nome-do-computador.exemplo.com.br

Independente do caso, sempre será solicitado a senha de login no computador remoto, para validar e encriptar a conexão.

Detalhes implícitos

• O usuário precisa ter permissão de login no computador remoto;
• Se for o primeiro login, será criada a pasta /home/nome-do-usuario no computador remoto;

Simplificando um pouco mais o processo

Para evitarmos a digitação da senha de login a cada nova conexão ao computador remoto sem prejudicar a segurança na comunicação e conseguir automatizar a execução de comandos e/ou scripts no computador remoto, é necessário a criação e troca das chaves SSH previamente entre os computadores envolvidos, conforme os passos abaixo:

1. Criando as chaves SSH (pública e privada);
2. Copiando a chave SSH (pública) para o servidor SSH;
3. Executando comandos no servidor SSH.

Criando as chaves SSH (pública e privada)

Execute o comando ssh-keygen (disponível no pacote openssh-client) sem passar parâmetros e aceite as opções padrões teclando [ENTER], conforme abaixo:

sandro@ubuntu:~$ ssh-keygen 
Generating public/private rsa key pair.
Enter file in which to save the key (/home/sandro/.ssh/id_rsa): [ENTER]
Created directory '/home/sandro/.ssh'.
Enter passphrase (empty for no passphrase): [ENTER]
Enter same passphrase again: [ENTER]
Your identification has been saved in /home/sandro/.ssh/id_rsa
Your public key has been saved in /home/sandro/.ssh/id_rsa.pub
The key fingerprint is:
SHA256:i+BpQVG5QSQBfy2z6irKh8uJ41Zd/UDiDa0WT/j7RkE sandro@ubuntu
The key's randomart image is:
+---[RSA 3072]----+
|  ..+=+.o        |
|   . oo* + E     |
|    o =o& .      |
|   . ..O * .     |
|    + + S + .    |
|   o * . o o     |
|  o = . . o      |
|*o.+       o     |
|*O+..     .      |
+----[SHA256]-----+

Dessa forma será gerado um conjunto de chaves RSA (sem senha de segurança) na pasta /home/sandro/.ssh, conforme abaixo:

sandro@ubuntu:~$ cd ~/.ssh
sandro@ubuntu:~$ pwd
/home/sandro/.ssh
sandro@ubuntu:~$ ls -la
drwx — — — 2  sandro sandro 4096 mar 5 2022 .
drwxr-xr-x 61 sandro sandro 4096 set 19 06:39 ..
-rw — — — — 1 sandro sandro 2610 out 25 2021 id_rsa
-rw-r — r — 1 sandro sandro 575  out 25 2021 id_rsa.pub

Observe que a chave privada id_rsa está configurada para acesso restrito ao proprietário, enquanto a chave pública id_rsa.pub tem a leitura liberada para qualquer usuário.

Lembre-se.: Se alguém tiver acesso às suas chaves pública e privada, poderá logar nos computadores remotos com seu usuário. Para mitigar esse risco é recomendável que no processo de criação, visto acima, seja informada uma senha.

Para conhecer todas as opções disponíveis na criação das chaves SSH, execute man ssh-keygen.

Copiando a chave SSH (pública) para o servidor SSH

Veja como é simples copiar sua chave SSH para o computador remoto. Use o comando ssh-copy-id, conforme abaixo:

sandro@ubuntu:~$ ssh-copy-id node01
/usr/bin/ssh-copy-id: INFO: Source of key(s) to be installed: "/home/sandro/.ssh/id_rsa.pub"
The authenticity of host 'node01 (172.30.2.2)' can't be established.
ECDSA key fingerprint is SHA256:OvIkq0qqws0HP70HLCCdX31wLWoI/yvcN+sCCN3Krts.
Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
/usr/bin/ssh-copy-id: INFO: attempting to log in with the new key(s), to filter out any that are already installed
/usr/bin/ssh-copy-id: INFO: 1 key(s) remain to be installed -- if you are prompted now it is to install the new keys
sandro@node01's password: [INFORME A SENHA]
Number of key(s) added: 1
Now try logging into the machine, with:   "ssh 'node01'"
and check to make sure that only the key(s) you wanted were added.

Detalhando o processo

/usr/bin/ssh-copy-id: INFO: Source of key(s) to be installed: "/home/sandro/.ssh/id_rsa.pub"

Como não especificamos qual chave pública copiar para o computador remoto, será utilizada a chave padrão criada anteriormente.

The authenticity of host 'node01 (172.30.2.2)' can't be established.
ECDSA key fingerprint is SHA256:OvIkq0qqws0HP70HLCCdX31wLWoI/yvcN+sCCN3Krts.
Are you sure you want to continue connecting (yes/no/[fingerprint])? yes

Em linhas gerais ‘Não pudemos validar a autenticidade do node01, você confia nele? podemos continuar?’, se você responder que sim a chave ECDSA do computador remoto será gravada no arquivo de computadores conhecidos /home/sandro/.ssh/known_hosts do computador local.

/usr/bin/ssh-copy-id: INFO: attempting to log in with the new key(s), to filter out any that are already installed
/usr/bin/ssh-copy-id: INFO: 1 key(s) remain to be installed -- if you are prompted now it is to install the new keys
sandro@node01's password: [INFORME A SENHA]

Neste momento é solicitado sua senha de login no computador remoto e uma vez logado a sua chave pública é gravada no arquivo de chaves autorizadas /home/sandro/.ssh/authorized_keys no computador remoto.

Number of key(s) added: 1
Now try logging into the machine, with:   "ssh 'node01'"
and check to make sure that only the key(s) you wanted were added.

Pronto! Processo finalizado!

Executando comandos no servidor SSH

Com a troca de chaves entre os computadores (cliente e servidor) concluída, a necessidade de digitação da senha de login à cada conexão deixa de existir, então agora podemos dar um passo adiante.

Lembrando que ao acessar o computador remoto utilizando a sintaxe ssh [nome-do-usuario@]nome-do-computador.exemplo.com.br vai ser disponibilizado o terminal remoto para trabalharmos, e quando terminarmos e digitarmos exit a conexão é fechada e voltamos ao computador local.

Agora se já soubermos o que precisamos fazer no computador remoto e quisermos agilizar um pouco mais o processo, podemos utilizar o SSH da seguinte forma ssh nome-do-computador.exemplo.com.br [COMANDO|SCRIPT], vejamos alguns exemplos abaixo:

#1 Apenas um comando, super simples

$ # Consultando o nome do computador remoto
$ ssh node01 hostname
node01
$
$ # Exibindo o conteudo de um arquivo que está no computador remoto
$ ssh node01 cat /etc/resolv.conf
... conteudo omitido ...
nameserver 8.8.8.8
nameserver 1.1.1.1
$

#2 Mais de um comando, ainda é simples

Para executar mais de um comando na mesma conexão, precisamos passar os comando como se fosse uma única string.

$ ssh node01 "sleep 3; hostname"

Ou assim:

ssh node01 "for i in {1..5}; do date; hostname; sleep 1; done"

Lembrando que o ‘;’ (ponto e virgula) no Shell sinaliza que um comando terminou e um novo comando se inicia, dessa forma podemos enviar praticamente qualquer conjunto de comandos para o computador remoto.

Com base no artigo ‘SSH argument length’, para verificarmos o tamanho máximo da string de comandos que podemos enviar para um determinado servidor SSH, execute o seguinte:

$ ssh node01 "getconf -a | grep ARG_MAX"
ARG_MAX                            2097152
_POSIX_ARG_MAX                     2097152

Neste exemplo podemos enviar uma string de comando com até 2MB de tamanho (2.097.152/1024/1024 = 2).

#3 Enviando um script para execução remota

Para este teste vamos criar como exemplo o script01.sh com o seguinte conteúdo:

$ vim script01.sh
echo "Olá! Estamos na maquina '$( hostname )'."
for i in {1..5}; do
  date;
  sleep 1;
done

Para executar este script no computador remoto.

ssh node01 < script01.sh

#4 Automatizando a execução de comandos remotamente

Vamos criar o script02.sh com o seguinte conteúdo.

$ vim script02.sh
echo "Aqui estamos no computador local '$( hostname )'."
CMD_SSH="$( cat <<'EOF'
echo "Agora estamos no computador remoto '$( hostname )'."
for i in {1..5}; do
  date;
  sleep 1;
done
EOF
)"
ssh node01 "$CMD_SSH"
echo "E voltamos para o computador local '$( hostname )' de novo."

A primeira linha imprime uma mensagem com o nome do computador local, na sequencia criamos a variável CMD_SSH com o conteúdo do script que será executado no computador remoto.

Para melhorar a legibilidade do código gravado na variável CMD_SSH, foi utilizado o recurso Here Document com o delimitador EOF (que podeira ter sido qualquer outro) e assim termos uma string com múltiplas linhas.

Depois efetuamos a conexão SSH no computador ‘node01’ utilizando os comandos armazenados na variável CMD_SSH.

E pra finalizar imprimimos uma nova mensagem com o nome do computador local. Vamos ver abaixo o resultado da execução.

$ # Configurando o script como executável
$ chmod +x script02..sh
$
$ ./script02.sh
Aqui estamos no computador local 'localhost'.
Agora estamos no computador remoto 'node01'.
Thu Sep 29 00:51:55 UTC 2022
Thu Sep 29 00:51:56 UTC 2022
Thu Sep 29 00:51:57 UTC 2022
Thu Sep 29 00:51:58 UTC 2022
Thu Sep 29 00:51:59 UTC 2022
E voltamos para o computador local 'localhost' de novo.

#4 Usando o `sudo`

Neste artigo não vamos entrar no mérito da configuração do acesso de super-usuário.

Se o seu usuário não tiver permissões de sudo no computador remoto, e tentar executar uma ação privilegiada, teremos como resultado o seguinte:

$ ssh sandro@node01 wc -l /etc/shadow
wc: /etc/shadow: Permission denied

Bom! Então após providenciar o acesso de sudo pro nosso usuário e tentar de novo, receberemos a seguinte mensagem.

$ ssh sandro@node01 sudo wc -l /etc/shadow
sudo: a terminal is required to read the password; either use the -S option to read from standard input or configure an askpass helper

Temos a permissão! mas precisamos confirmar nossa identidade digitando a nossa senha no computador remoto e para isso precisamos apresentar um terminal durante a conexão. Nestes casos utilizamos a opção -t , conforme abaixo:

$ ssh -t sandro@node01 sudo wc -l /etc/shadow
[sudo] senha para sandro: [SENHA]
36 /etc/shadow

Conclusão

Espero que este artigo tenha lhe ajudado a entender o funcionamento básico do SSH.

Gostou do conteúdo? Bata palmas pra este artigo logo abaixo, compartilhe nas suas redes sociais e me siga aqui no Medium para receber as notificações dos próximos artigos.

Sentiu falta de algo? quer conversar a respeito? tem alguma dúvida, crítica ou sugestão? deixe seu comentário abaixo.

Para colocar em prática tudo que foi visto aqui, de forma segura e gratuita, fique a vontade neste ambiente interativo.

Obrigado pela atenção, até o próximo! Fui!

Se quiser saber o que estou estudando, experimentando ou escrevendo, visite o meu Diário de Bordo e veja as novidades.