Introdução
O SSH é um protocolo seguro usado como o principal meio de conexão com servidores Linux remotamente. Ele fornece uma interface baseada em texto, criando um shell remoto. Após a conexão, todos os comandos que você digita no seu terminal local são enviados para o servidor remoto e executados lá.
Neste guia no estilo “cheat sheet”, vamos cobrir algumas maneiras comuns de conectar-se com SSH para alcançar seus objetivos. Isso pode ser usado como uma referência rápida quando você precisar saber como se conectar ou configurar seu servidor de diferentes maneiras.
Implante suas aplicações frontend do GitHub usando a Plataforma de Aplicativos da DigitalOcean. Deixe a DigitalOcean focar em dimensionar sua aplicação.
Como Usar Este Guia
- Leia a seção Visão Geral do SSH primeiro se você não estiver familiarizado com o SSH em geral ou estiver apenas começando.
- Use as seções subsequentes que forem aplicáveis ao que você está tentando alcançar. A maioria das seções não é baseada em nenhuma outra, então você pode usar os exemplos a seguir de forma independente.
- Use o menu de conteúdo no lado esquerdo desta página (em larguras de página amplas) ou a função de busca do seu navegador para localizar as seções de que precisa.
- Copie e cole os exemplos de linha de comando fornecidos, substituindo os valores
destacadospelos seus próprios valores.
Visão geral do SSH
A forma mais comum de se conectar a um servidor Linux remoto é através do SSH. SSH significa Secure Shell e fornece uma maneira segura de executar comandos, fazer alterações e configurar serviços remotamente. Quando você se conecta através do SSH, faz login usando uma conta que existe no servidor remoto.
Como o SSH Funciona
Ao se conectar através do SSH, você será direcionado para uma sessão de shell, que é uma interface baseada em texto onde você pode interagir com seu servidor. Durante toda a sua sessão SSH, quaisquer comandos que você digitar no seu terminal local são enviados por meio de um túnel SSH criptografado e executados no seu servidor.
A conexão SSH é implementada usando um modelo cliente-servidor. Isso significa que, para que uma conexão SSH seja estabelecida, a máquina remota deve estar executando um software chamado daemon SSH. Esse software aguarda conexões em uma porta de rede específica, autentica solicitações de conexão e inicia o ambiente apropriado se o usuário fornecer as credenciais corretas.
O computador do usuário deve ter um cliente SSH. Este é um software que sabe como se comunicar usando o protocolo SSH e pode receber informações sobre o host remoto para se conectar, o nome de usuário a ser usado e as credenciais que devem ser passadas para autenticação. O cliente também pode especificar detalhes sobre o tipo de conexão que deseja estabelecer.
Como o SSH autentica os usuários
Os clientes geralmente se autenticam usando senhas (menos seguro e não recomendado) ou chaves SSH, que são muito seguras.
As entradas de senha são criptografadas e são fáceis de entender para novos usuários. No entanto, bots automatizados e usuários maliciosos frequentemente tentarão repetidamente autenticar em contas que permitem logins baseados em senha, o que pode levar a comprometimentos de segurança. Por esse motivo, recomendamos sempre configurar a autenticação baseada em chaves SSH para a maioria das configurações.
Chaves SSH são um conjunto correspondente de chaves criptográficas que podem ser usadas para autenticação. Cada conjunto contém uma chave pública e uma chave privada. A chave pública pode ser compartilhada livremente sem preocupações, enquanto a chave privada deve ser guardada com vigilância e nunca exposta a ninguém.
Para autenticar usando chaves SSH, um usuário deve ter um par de chaves SSH em seu computador local. No servidor remoto, a chave pública deve ser copiada para um arquivo dentro do diretório pessoal do usuário em ~/.ssh/authorized_keys. Este arquivo contém uma lista de chaves públicas, uma por linha, que estão autorizadas a fazer login nesta conta.
Quando um cliente se conecta ao host, desejando usar autenticação de chave SSH, ele informará ao servidor dessa intenção e dirá ao servidor qual chave pública usar. O servidor então verifica seu arquivo authorized_keys em busca da chave pública, gera uma string aleatória e a criptografa usando a chave pública. Esta mensagem criptografada só pode ser descriptografada com a chave privada associada. O servidor enviará esta mensagem criptografada ao cliente para testar se ele realmente possui a chave privada associada.
Ao receber esta mensagem, o cliente a descriptografará usando a chave privada e combinará a string aleatória revelada com um ID de sessão previamente negociado. Em seguida, ele gera um hash MD5 desse valor e o transmite de volta ao servidor. O servidor já tinha a mensagem original e o ID de sessão, então pode comparar um hash MD5 gerado por esses valores e determinar que o cliente deve ter a chave privada.
Agora que você sabe como o SSH funciona, podemos começar a discutir alguns exemplos para demonstrar diferentes maneiras de trabalhar com SSH.
Gerar e Trabalhar com Chaves SSH
Esta seção abordará como gerar chaves SSH em uma máquina cliente e distribuir a chave pública para servidores onde elas devem ser usadas. Esta é uma boa seção para começar se você ainda não gerou chaves anteriormente, devido à segurança aumentada que permite para conexões futuras.
Gerando um Par de Chaves SSH
Gerar um novo par de chaves pública e privada SSH no seu computador local é o primeiro passo para autenticar-se com um servidor remoto sem uma senha. A menos que haja uma boa razão para não fazer isso, você sempre deve autenticar-se usando chaves SSH.
A number of cryptographic algorithms can be used to generate SSH keys, including RSA, DSA, and ECDSA. RSA keys are generally preferred and are the default key type.
Para gerar um par de chaves RSA no seu computador local, digite:
Generating public/private rsa key pair.
Enter file in which to save the key (/home/demo/.ssh/id_rsa):
Este prompt permite que você escolha o local para armazenar sua chave privada RSA. Pressione ENTER para deixar isso como padrão, o que irá armazená-las no diretório oculto .ssh no diretório home do seu usuário. Deixar o local padrão selecionado permitirá que seu cliente SSH encontre as chaves automaticamente.
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
O próximo prompt permite que você insira uma frase secreta de comprimento arbitrário para proteger sua chave privada. Por padrão, você terá que inserir qualquer frase secreta definida aqui toda vez que usar a chave privada, como uma medida de segurança adicional. Sinta-se à vontade para pressionar ENTER para deixar isso em branco se você não quiser uma frase secreta. No entanto, tenha em mente que isso permitirá que qualquer pessoa que obtenha controle de sua chave privada faça login em seus servidores.
Se optar por inserir uma frase secreta, nada será exibido enquanto você digita. Esta é uma precaução de segurança.
OutputYour identification has been saved in /root/.ssh/id_rsa.
Your public key has been saved in /root/.ssh/id_rsa.pub.
The key fingerprint is:
8c:e9:7c:fa:bf:c4:e5:9c:c9:b8:60:1f:fe:1c:d3:8a root@here
The key's randomart image is:
+--[ RSA 2048]----+
| |
| |
| |
| + |
| o S . |
| o . * + |
| o + = O . |
| + = = + |
| ....Eo+ |
+-----------------+
Este procedimento gerou um par de chaves SSH RSA, localizado no diretório oculto .ssh dentro do diretório doméstico do seu usuário. Estes arquivos são:
~/.ssh/id_rsa: A chave privada. NÃO COMPARTILHE ESTE ARQUIVO!~/.ssh/id_rsa.pub: A chave pública associada. Isso pode ser compartilhado livremente sem consequências.
Gerar um Par de Chaves SSH com um Maior Número de Bits
As chaves SSH têm 2048 bits por padrão. Isso geralmente é considerado suficiente para segurança, mas você pode especificar um número maior de bits para uma chave mais endurecida.
Para fazer isso, inclua o argumento -b com o número de bits desejado. A maioria dos servidores suporta chaves com um comprimento de pelo menos 4096 bits. Chaves mais longas podem não ser aceitas por motivos de proteção contra DDOS:
Se você tiver criado anteriormente uma chave diferente, será perguntado se deseja substituir sua chave anterior:
Overwrite (y/n)?
Se escolher “sim”, sua chave anterior será substituída e você não poderá mais fazer login nos servidores usando essa chave. Por causa disso, certifique-se de substituir as chaves com cautela.
Removendo ou Alterando a Frase de Senha em uma Chave Privada
Se você gerou uma frase de senha para sua chave privada e deseja alterá-la ou removê-la, pode fazer isso facilmente.
Nota: Para alterar ou remover a frase de senha, você deve saber a frase de senha original. Se perdeu a frase de senha da chave, não há recurso e você terá que gerar um novo par de chaves.
Para alterar ou remover a frase de senha, basta digitar:
Enter file in which the key is (/root/.ssh/id_rsa):
Você pode digitar o local da chave que deseja modificar ou pressionar ENTER para aceitar o valor padrão:
Enter old passphrase:
Digite a senha antiga que deseja alterar. Em seguida, será solicitada uma nova frase de senha:
Enter new passphrase (empty for no passphrase):
Enter same passphrase again:
Aqui, digite sua nova frase de senha ou pressione ENTER para remover a frase de senha.
Exibindo a Impressão Digital da Chave SSH
Cada par de chaves SSH compartilha uma única “impressão digital” criptográfica que pode ser usada para identificar unicamente as chaves. Isso pode ser útil em diversas situações.
Para descobrir a impressão digital de uma chave SSH, digite:
Enter file in which the key is (/root/.ssh/id_rsa):
Você pode pressionar ENTER se essa for a localização correta da chave, caso contrário, digite a localização revisada. Você receberá uma string que contém o comprimento do bit da chave, a impressão digital, a conta e o host para os quais foi criada e o algoritmo usado:
Output4096 8e:c4:82:47:87:c2:26:4b:68:ff:96:1a:39:62:9e:4e demo@test (RSA)
Copiando sua Chave Pública SSH para um Servidor com SSH-Copy-ID
Para copiar sua chave pública para um servidor, permitindo que você se autentique sem uma senha, podem ser adotadas várias abordagens.
Se você atualmente tem acesso SSH baseado em senha configurado para o seu servidor e tem o utilitário ssh-copy-id instalado, este é um processo simples. A ferramenta ssh-copy-id está incluída em muitas distribuições Linux nos pacotes OpenSSH, então é muito provável que esteja instalada por padrão.
Se você tiver essa opção, pode transferir facilmente sua chave pública digitando:
Isso solicitará a senha da conta de usuário no sistema remoto:
The authenticity of host '111.111.11.111 (111.111.11.111)' can't be established.
ECDSA key fingerprint is fd:fd:d4:f9:77:fe:73:84:e1:55:00:ad:d6:6d:22:fe.
Are you sure you want to continue connecting (yes/no)? 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
[email protected]'s password:
Depois de digitar a senha, o conteúdo de sua chave ~/.ssh/id_rsa.pub será adicionado ao final do arquivo ~/.ssh/authorized_keys da conta de usuário:
OutputNumber of key(s) added: 1
Now try logging into the machine, with: "ssh '[email protected]'"
and check to make sure that only the key(s) you wanted were added.
Agora é possível fazer login nessa conta sem uma senha:
Copiando sua Chave Pública SSH para um Servidor sem o SSH-Copy-ID
Se você não tem a utilidade ssh-copy-id disponível, mas ainda tem acesso SSH baseado em senha ao servidor remoto, você pode copiar o conteúdo da sua chave pública de uma maneira diferente.
Você pode exibir o conteúdo da chave e enviá-lo para o comando ssh. Do lado remoto, você pode garantir que o diretório ~/.ssh exista e, em seguida, anexar o conteúdo enviado para o arquivo ~/.ssh/authorized_keys:
Será solicitado que você forneça a senha da conta remota:
The authenticity of host '111.111.11.111 (111.111.11.111)' can't be established.
ECDSA key fingerprint is fd:fd:d4:f9:77:fe:73:84:e1:55:00:ad:d6:6d:22:fe.
Are you sure you want to continue connecting (yes/no)? yes
[email protected]'s password:
Após inserir a senha, sua chave será copiada, permitindo que você faça login sem uma senha:
Copiando sua Chave Pública SSH para um Servidor Manualmente
Se você não tem acesso SSH baseado em senha disponível, precisará adicionar sua chave pública ao servidor remoto manualmente.
Em sua máquina local, você pode encontrar o conteúdo do seu arquivo de chave pública digitando:
Outputssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQCqql6MzstZYh1TmWWv11q5O3pISj2ZFl9HgH1JLknLLx44+tXfJ7mIrKNxOOwxIxvcBF8PXSYvobFYEZjGIVCEAjrUzLiIxbyCoxVyle7Q+bqgZ8SeeM8wzytsY+dVGcBxF6N4JS+zVk5eMcV385gG3Y6ON3EG112n6d+SMXY0OEBIcO6x+PnUSGHrSgpBgX7Ks1r7xqFa7heJLLt2wWwkARptX7udSq05paBhcpB0pHtA1Rfz3K2B+ZVIpSDfki9UVKzT8JUmwW6NNzSgxUfQHGwnW7kj4jp4AT0VZk3ADw497M2G/12N0PPB5CnhHf7ovgy6nL1ikrygTKRFmNZISvAcywB9GVqNAVE+ZHDSCuURNsAInVzgYo9xgJDW8wUw2o8U77+xiFxgI5QSZX3Iq7YLMgeksaO4rBJEa54k8m5wEiEE1nUhLuJ0X/vh2xPff6SQ1BL/zkOhvJCACK6Vb15mDOeCSq54Cr7kvS46itMosi/uS66+PujOO+xt/2FWYepz6ZlN70bRly57Q06J+ZJoc9FfBCbCyYH7U/ASsmY095ywPsBo1XQ9PqhnN1/YOorJ068foQDNVpm146mUpILVxmq41Cj55YKHEazXGsdBIbXWhcrRf4G2fJLRcGUr9q8/lERo9oxRm5JFX6TCmj6kmiFqv+Ow9gI0x8GvaQ== demo@test
Você pode copiar este valor e colá-lo manualmente no local apropriado no servidor remoto. Você terá que fazer login no servidor remoto por outros meios (como o console web DigitalOcean).
No servidor remoto, crie o diretório ~/.ssh se ele ainda não existir:
Em seguida, você pode criar ou acrescentar o arquivo ~/.ssh/authorized_keys digitando:
Agora você deverá conseguir fazer login no servidor remoto sem senha.
Instruções Básicas de Conexão
A seguinte seção abordará alguns conceitos básicos sobre como conectar-se a um servidor com SSH.
Conectando-se a um Servidor Remoto
Para se conectar a um servidor remoto e abrir uma sessão de terminal lá, você pode usar o comando ssh.
A forma mais simples assume que seu nome de usuário em sua máquina local é o mesmo que no servidor remoto. Se isso for verdadeiro, você pode conectar-se usando:
Se seu nome de usuário for diferente no servidor remoto, você precisa passar o nome de usuário remoto assim:
Na sua primeira conexão com um novo host, você verá uma mensagem que se parece com esta:
The authenticity of host '111.111.11.111 (111.111.11.111)' can't be established.
ECDSA key fingerprint is fd:fd:d4:f9:77:fe:73:84:e1:55:00:ad:d6:6d:22:fe.
Are you sure you want to continue connecting (yes/no)? yes
Digite sim para aceitar a autenticidade do host remoto.
Se estiver utilizando autenticação por senha, será solicitada a senha da conta remota aqui. Se estiver usando chaves SSH, será solicitada a frase secreta da sua chave privada, caso esteja configurada; caso contrário, você será conectado automaticamente.
Executando um Único Comando em um Servidor Remoto
Para executar um único comando em um servidor remoto, em vez de iniciar uma sessão de terminal, você pode adicionar o comando após as informações de conexão, como mostrado abaixo:
Isso irá conectar ao host remoto, autenticar com suas credenciais e executar o comando especificado. A conexão será encerrada imediatamente em seguida.
Conectando-se a um Servidor com uma Porta Diferente
Por padrão, o daemon SSH em um servidor é executado na porta 22. Seu cliente SSH assumirá que este é o caso ao tentar conectar. Se o seu servidor SSH estiver ouvindo em uma porta não padrão (como é demonstrado em uma seção posterior), você precisará especificar o novo número da porta ao conectar com seu cliente.
Você pode fazer isso especificando o número da porta com a opção -p:
Para evitar ter que fazer isso toda vez que entrar no seu servidor remoto, você pode criar ou editar um arquivo de configuração no diretório ~/.ssh dentro do diretório principal do seu computador local.
Edite ou crie o arquivo agora digitando:
Aqui, você pode definir opções de configuração específicas do host. Para especificar sua nova porta, use um formato como este:
Host remote_alias
HostName remote_host
Port port_num
Isso permitirá que você faça login sem especificar o número da porta específica na linha de comando.
Adicionando suas Chaves SSH a um Agente SSH para Evitar Digitar a Senha
Se você tiver uma senha na sua chave SSH privada, será solicitado que você digite a senha toda vez que a usar para se conectar a um host remoto.
Para evitar ter que fazer isso repetidamente, você pode executar um agente SSH. Este pequeno utilitário armazena sua chave privada depois de você ter inserido a senha pela primeira vez. Ela estará disponível durante a sessão do seu terminal, permitindo que você se conecte no futuro sem precisar digitar novamente a senha.
Isso também é importante se você precisar encaminhar suas credenciais SSH (mostrado posteriormente).
Para iniciar o Agente SSH, digite o seguinte na sua sessão de terminal local:
OutputAgent pid 10891
Isso iniciará o programa do agente e o colocará em segundo plano. Agora, você precisa adicionar sua chave privada ao agente, para que ele possa gerenciar sua chave:
Enter passphrase for /home/demo/.ssh/id_rsa:
Identity added: /home/demo/.ssh/id_rsa (/home/demo/.ssh/id_rsa)
Você terá que inserir sua frase secreta (se uma estiver definida). Depois, seu arquivo de identidade é adicionado ao agente, permitindo que você use sua chave para fazer login sem precisar inserir a frase secreta novamente.
Encaminhando suas Credenciais SSH para Usar em um Servidor
Se deseja ser capaz de conectar-se a um servidor sem senha de dentro de outro servidor, será necessário encaminhar as informações de sua chave SSH. Isso permitirá que você se autentique em outro servidor através do servidor ao qual está conectado, usando as credenciais em seu computador local.
Para começar, você deve ter seu agente SSH iniciado e sua chave SSH adicionada ao agente (veja anteriormente). Depois disso, você precisa se conectar ao seu primeiro servidor usando a opção -A. Isso encaminha suas credenciais para o servidor para esta sessão:
A partir daqui, você pode fazer SSH para qualquer outro host para o qual sua chave SSH esteja autorizada a acessar. Você se conectará como se sua chave SSH privada estivesse localizada neste servidor.
Opções de Configuração no Lado do Servidor
Esta seção contém algumas opções comuns de configuração do lado do servidor que podem moldar a forma como o seu servidor responde e que tipos de conexões são permitidas.
Desativando a Autenticação por Senha
Se você tiver chaves SSH configuradas, testadas e funcionando corretamente, é provavelmente uma boa ideia desativar a autenticação por senha. Isso impedirá que qualquer usuário faça login com SSH usando uma senha.
Para fazer isso, conecte-se ao seu servidor remoto e abra o arquivo /etc/ssh/sshd_config com privilégios de root ou sudo:
No interior do arquivo, procure a diretiva PasswordAuthentication. Se estiver comentada, descomente-a. Defina-a como não para desativar os logins por senha:
PasswordAuthentication no
Depois de fazer a alteração, salve e feche o arquivo. Para implementar as alterações, você deve reiniciar o serviço SSH.
No Ubuntu/Debian:
No CentOS/Fedora:
Agora, todas as contas no sistema não poderão fazer login com SSH usando senhas.
Alterando a Porta em que o Daemon SSH Opera
Alguns administradores sugerem que você altere a porta padrão na qual o SSH é executado. Isso pode ajudar a diminuir o número de tentativas de autenticação às quais seu servidor é submetido por bots automatizados.
Para alterar a porta na qual o daemon SSH escuta, você precisará fazer login no seu servidor remoto. Abra o arquivo sshd_config no sistema remoto com privilégios de root, seja fazendo login com esse usuário ou usando sudo:
Uma vez dentro, você pode alterar a porta na qual o SSH é executado encontrando a especificação Port 22 e modificando-a para refletir a porta que deseja usar. Por exemplo, para alterar a porta para 4444, coloque isso no seu arquivo:
#Port 22
Port 4444
Salve e feche o arquivo quando terminar. Para implementar as alterações, você deve reiniciar o daemon SSH.
No Ubuntu/Debian:
No CentOS/Fedora:
Depois que o daemon reiniciar, você precisará autenticar especificando o número da porta (demonstrado em uma seção anterior).
Limitando os Usuários que Podem Conectar-se via SSH
Para limitar explicitamente as contas de usuário que podem fazer login via SSH, você pode adotar algumas abordagens diferentes, cada uma envolvendo a edição do arquivo de configuração do daemon SSH.
No seu servidor remoto, abra este arquivo agora com privilégios de root ou sudo:
O primeiro método de especificar as contas que podem fazer login é usando a diretiva AllowUsers. Procure pela diretiva AllowUsers no arquivo. Se ela não existir, crie-a em qualquer lugar. Após a diretiva, liste as contas de usuário que devem ser permitidas a fazer login via SSH:
AllowUsers user1 user2
Salve e feche o arquivo. Reinicie o daemon para implementar suas alterações.
No Ubuntu/Debian:
No CentOS/Fedora:
Se você se sentir mais confortável com o gerenciamento de grupos, pode usar a diretiva AllowGroups em vez disso. Se este for o caso, adicione apenas um único grupo que deve ter acesso SSH (vamos criar este grupo e adicionar membros em breve):
AllowGroups sshmembers
Salve e feche o arquivo.
Agora, você pode criar um grupo de sistema (sem diretório home) correspondente ao grupo que você especificou digitando:
Certifique-se de adicionar as contas de usuário necessárias a este grupo. Isso pode ser feito digitando:
Agora, reinicie o daemon SSH para implementar suas alterações.
No Ubuntu/Debian:
No CentOS/Fedora:
Desabilitando o Login do Root
É frequentemente aconselhável desabilitar completamente o login do root via SSH depois de configurar uma conta de usuário SSH que tenha privilégios de sudo.
Para fazer isso, abra o arquivo de configuração do daemon SSH com o root ou sudo no seu servidor remoto.
Dentro, procure por uma diretiva chamada PermitRootLogin. Se estiver comentada, descomente-a. Altere o valor para “no”:
PermitRootLogin no
Salve e feche o arquivo. Para implementar suas alterações, reinicie o daemon SSH.
No Ubuntu/Debian:
No CentOS/Fedora:
Permitindo Acesso Root para Comandos Específicos
Há casos em que você pode querer desativar o acesso root de forma geral, mas ativá-lo para permitir que determinados aplicativos sejam executados corretamente. Um exemplo disso pode ser uma rotina de backup.
Isso pode ser realizado através do arquivo authorized_keys do usuário root, que contém chaves SSH autorizadas a usar a conta.
Adicione a chave do seu computador local que você deseja usar para esse processo (recomendamos criar uma nova chave para cada processo automático) ao arquivo authorized_keys do usuário root no servidor. Vamos demonstrar com o comando ssh-copy-id aqui, mas você pode usar qualquer um dos métodos de cópia de chaves que discutimos em outras seções:
Agora, faça login no servidor remoto. Precisaremos ajustar a entrada no arquivo authorized_keys, então abra-o com acesso de root ou sudo:
No início da linha com a chave que você enviou, adicione um command= listando o comando para o qual esta chave é válida. Isso deve incluir o caminho completo para o executável, além de quaisquer argumentos:
command="/path/to/command arg1 arg2" ssh-rsa ...
Salve e feche o arquivo quando terminar.
Agora, abra o arquivo sshd_config com privilégios de root ou sudo:
Encontre a diretiva PermitRootLogin e altere o valor para forced-commands-only. Isso permitirá apenas logins SSH com chave usar root quando um comando for especificado para a chave:
PermitRootLogin forced-commands-only
Salve e feche o arquivo. Reinicie o daemon SSH para implementar suas alterações.
No Ubuntu/Debian:
No CentOS/Fedora:
Encaminhamento de Exibições de Aplicativos X para o Cliente
O daemon SSH pode ser configurado para encaminhar automaticamente a exibição de aplicativos X no servidor para a máquina cliente. Para que isso funcione corretamente, o cliente deve ter um sistema de janelas X configurado e habilitado.
Para habilitar essa funcionalidade, faça login no seu servidor remoto e edite o arquivo sshd_config como root ou com privilégios de sudo:
Procure pela diretiva X11Forwarding. Se estiver comentada, descomente-a. Crie-a, se necessário, e defina o valor como “yes”:
X11Forwarding yes
Guardar e fechar o arquivo. Reinicie o seu daemon SSH para implementar essas mudanças.
No Ubuntu/Debian:
No CentOS/Fedora:
Para conectar ao servidor e encaminhar a exibição de um aplicativo, você precisa passar a opção -X do cliente durante a conexão:
Aplicações gráficas iniciadas no servidor através desta sessão devem ser exibidas no computador local. O desempenho pode ser um pouco lento, mas é muito útil em caso de necessidade.
Opções de Configuração do Lado do Cliente
Na próxima seção, vamos nos concentrar em alguns ajustes que você pode fazer no lado do cliente da conexão.
Definindo Informações de Conexão Específicas do Servidor
No seu computador local, você pode definir configurações individuais para alguns ou todos os servidores aos quais você se conecta. Estas podem ser armazenadas no arquivo ~/.ssh/config, que é lido pelo seu cliente SSH cada vez que é chamado.
Crie ou abra este arquivo no seu editor de texto no seu computador local:
Dentro, você pode definir opções de configuração individuais introduzindo cada uma com a palavra-chave Host, seguida de um alias. Abaixo disso e indentado, você pode definir qualquer uma das diretivas encontradas na página do manual ssh_config:
Um exemplo de configuração seria:
Host testhost
HostName your_domain
Port 4444
User demo
Você então poderia se conectar ao seu_domínio na porta 4444 usando o nome de usuário demo simplesmente digitando:
Você também pode usar curingas para corresponder a mais de um host. Tenha em mente que correspondências posteriores podem substituir as anteriores. Por causa disso, você deve colocar suas correspondências mais gerais no topo. Por exemplo, você poderia definir todas as conexões para não permitir o encaminhamento X por padrão, com uma substituição para seu_domínio tendo isso em seu arquivo:
Host *
ForwardX11 no
Host testhost
HostName your_domain
ForwardX11 yes
Port 4444
User demo
Salve e feche o arquivo quando terminar.
Mantendo Conexões Ativas para Evitar Timeouts
Se você se encontrar sendo desconectado das sessões SSH antes de estar pronto, é possível que sua conexão esteja expirando.
Você pode configurar seu cliente para enviar um pacote para o servidor de tempos em tempos para evitar essa situação:
Em seu computador local, você pode configurar isso para cada conexão editando seu arquivo ~/.ssh/config. Abra-o agora:
Se uma não existir, no topo do arquivo, defina uma seção que corresponda a todos os hosts. Configure o ServerAliveInterval para “120” para enviar um pacote para o servidor a cada dois minutos. Isso deve ser suficiente para notificar o servidor a não fechar a conexão:
Host *
ServerAliveInterval 120
Salve e feche o arquivo quando terminar.
Desabilitando a Verificação de Host
Por padrão, sempre que você se conectar a um novo servidor, será mostrada a impressão digital da chave do host do daemon SSH remoto.
The authenticity of host '111.111.11.111 (111.111.11.111)' can't be established.
ECDSA key fingerprint is fd:fd:d4:f9:77:fe:73:84:e1:55:00:ad:d6:6d:22:fe.
Are you sure you want to continue connecting (yes/no)? yes
Isso é configurado para que você possa verificar a autenticidade do host ao qual está tentando se conectar e detectar instâncias em que um usuário malicioso possa estar tentando se passar pelo host remoto.
Em certas circunstâncias, você pode desejar desativar esse recurso. Observação: Isso pode ser um grande risco de segurança, portanto, certifique-se de saber o que está fazendo se configurar seu sistema dessa forma.
Para fazer a alteração, abra o arquivo ~/.ssh/config no seu computador local:
Se uma não existir, no topo do arquivo, defina uma seção que corresponda a todos os hosts. Configure a diretiva StrictHostKeyChecking como não para adicionar novos hosts automaticamente ao arquivo known_hosts. Configure o UserKnownHostsFile como /dev/null para não avisar sobre hosts novos ou alterados:
Host *
StrictHostKeyChecking no
UserKnownHostsFile /dev/null
Você pode habilitar a verificação caso a caso revertendo essas opções para outros hosts. O padrão para StrictHostKeyChecking é ask:
Host *
StrictHostKeyChecking no
UserKnownHostsFile /dev/null
Host testhost
HostName your_domain
StrictHostKeyChecking ask
UserKnownHostsFile /home/demo/.ssh/known_hosts
Multiplexação SSH sobre uma única conexão TCP
Existem situações em que estabelecer uma nova conexão TCP pode levar mais tempo do que você gostaria. Se você estiver fazendo múltiplas conexões para a mesma máquina, você pode aproveitar a multiplexação.
A multiplexação SSH reutiliza a mesma conexão TCP para várias sessões SSH. Isso elimina parte do trabalho necessário para estabelecer uma nova sessão, possivelmente acelerando as coisas. Limitar o número de conexões também pode ser útil por outros motivos.
Para configurar a multiplexação, você pode configurar manualmente as conexões, ou pode configurar seu cliente para usar automaticamente a multiplexação quando disponível. Demonstraremos a segunda opção aqui.
Para configurar a multiplexação, edite o arquivo de configuração do cliente SSH em sua máquina local:
Se você ainda não tem uma definição de host curinga no topo do arquivo, adicione uma agora (como Host *). Estaremos configurando os valores ControlMaster, ControlPath e ControlPersist para estabelecer nossa configuração de multiplexação.
O ControlMaster deve ser definido como “auto” para permitir automaticamente o multiplexação, se possível. O ControlPath estabelecerá o caminho para o socket de controle. A primeira sessão criará este socket e as sessões subsequentes poderão encontrá-lo porque ele é rotulado pelo nome de usuário, host e porta.
Definir a opção ControlPersist como 1 permitirá que a conexão mestre inicial seja colocada em segundo plano. O 1 especifica que a conexão TCP deve ser encerrada automaticamente um segundo após o fechamento da última sessão SSH:
Host *
ControlMaster auto
ControlPath ~/.ssh/multiplex/%r@%h:%p
ControlPersist 1
Salve e feche o arquivo quando terminar. Agora, precisamos realmente criar o diretório especificado no caminho de controle:
Agora, quaisquer sessões estabelecidas com a mesma máquina tentarão usar o socket e a conexão TCP existentes. Quando a última sessão é encerrada, a conexão será encerrada após um segundo.
Se por algum motivo você precisar ignorar temporariamente a configuração de multiplexação, pode fazer isso passando a flag -S com none:
Configurando Túneis SSH
Tunelar outro tráfego através de um túnel SSH seguro é uma excelente maneira de contornar configurações restritivas de firewall. Também é uma ótima maneira de criptografar o tráfego de rede que, de outra forma, estaria não criptografado.
Configurando Tunelamento Local para um Servidor
Conexões SSH podem ser usadas para tunelar tráfego de portas no host local para portas em um host remoto.
A local connection is a way of accessing a network location from your local computer through your remote host. First, an SSH connection is established to your remote host. On the remote server, a connection is made to an external (or internal) network address provided by the user and traffic to this location is tunneled to your local computer on a specified port.
Isso é frequentemente utilizado para tunelar para um ambiente de rede menos restrito, contornando um firewall. Outro uso comum é acessar uma interface web “apenas local” de um local remoto.
Para estabelecer um túnel local para o seu servidor remoto, você precisa usar o parâmetro -L ao se conectar e deve fornecer três informações adicionais:
- A porta local onde você deseja acessar a conexão tunelada.
- O host para o qual você deseja que seu host remoto se conecte.
- A porta na qual você deseja que seu host remoto se conecte.
Esses são fornecidos, na ordem acima (separados por dois-pontos), como argumentos para a flag -L. Também usaremos a flag -f, que faz com que o SSH entre em segundo plano antes de executar, e a flag -N, que não abre um shell ou executa um programa no lado remoto.
Por exemplo, para se conectar a seu_domínio na porta 80 no seu host remoto, tornando a conexão disponível em sua máquina local na porta 8888, você poderia digitar:
Agora, se você apontar seu navegador web local para 127.0.0.1:8888, você deverá ver qualquer conteúdo que esteja em seu_domínio na porta 80.
A more general guide to the syntax is:
Uma vez que a conexão está em segundo plano, você terá que encontrar o PID para encerrá-la. Você pode fazer isso procurando a porta que você encaminhou:
Output1001 5965 0.0 0.0 48168 1136 ? Ss 12:28 0:00 ssh -f -N -L 8888:your_domain:80 username@remote_host
1001 6113 0.0 0.0 13648 952 pts/2 S+ 12:37 0:00 grep --colour=auto 8888
Em seguida, você pode encerrar o processo direcionando o PID, que é o número na segunda coluna da linha que corresponde ao seu comando SSH:
Outra opção é iniciar a conexão sem a flag -f. Isso manterá a conexão em primeiro plano, impedindo você de usar a janela do terminal durante o encaminhamento. A vantagem disso é que você pode encerrar o túnel facilmente digitando CTRL-C.
Configurando o Encaminhamento Remoto para um Servidor
As conexões SSH podem ser usadas para encaminhar o tráfego de portas no host local para portas em um host remoto.
Em um túnel remoto, uma conexão é feita com um host remoto. Durante a criação do túnel, uma porta remota é especificada. Esta porta, no host remoto, será então encaminhada para uma combinação de host e porta conectada a partir do computador local. Isso permitirá que o computador remoto acesse um host através do seu computador local.
Isso pode ser útil se você precisar permitir o acesso a uma rede interna que está bloqueada para conexões externas. Se o firewall permitir conexões de saída da rede, isso permitirá que você se conecte a uma máquina remota e encaminhe o tráfego dessa máquina para uma localização na rede interna.
Para estabelecer um túnel remoto para o seu servidor remoto, você precisa usar o parâmetro -R ao se conectar e deve fornecer três peças de informações adicionais:
- A porta onde o host remoto pode acessar a conexão tunelada.
- O host ao qual você deseja que seu computador local se conecte.
- A porta à qual você deseja que seu computador local se conecte.
Esses são fornecidos, na ordem acima (separados por dois pontos), como argumentos para a bandeira -R. Também vamos usar a bandeira -f, que faz com que o SSH entre em segundo plano antes de executar e a bandeira -N, que não abre um shell ou executa um programa no lado remoto.
Por exemplo, para conectar ao seu_domínio na porta 80 em nosso computador local, tornando a conexão disponível em nosso host remoto na porta 8888, você poderia digitar:
Agora, no host remoto, abrir um navegador da web para 127.0.0.1:8888 permitiria ver qualquer conteúdo em seu_domínio na porta 80.
A more general guide to the syntax is:
Como a conexão está em segundo plano, você terá que encontrar seu PID para encerrá-lo. Você pode fazer isso pesquisando a porta que você encaminhou:
Output1001 5965 0.0 0.0 48168 1136 ? Ss 12:28 0:00 ssh -f -N -R 8888:your_domain:80 username@remote_host
1001 6113 0.0 0.0 13648 952 pts/2 S+ 12:37 0:00 grep --colour=auto 8888
Você pode então encerrar o processo direcionando o PID, que é o número na segunda coluna, da linha que corresponde ao seu comando SSH:
Outra opção é iniciar a conexão sem a flag -f. Isso manterá a conexão em primeiro plano, impedindo que você use a janela do terminal durante o encaminhamento. O benefício disso é que você pode encerrar facilmente o túnel digitando CTRL-C.
Configurando o Encaminhamento Dinâmico para um Servidor Remoto
Conexões SSH podem ser usadas para encaminhar o tráfego de portas no host local para portas em um host remoto.
A dynamic tunnel is similar to a local tunnel in that it allows the local computer to connect to other resources through a remote host. A dynamic tunnel does this by simply specifying a single local port. Applications that wish to take advantage of this port for tunneling must be able to communicate using the SOCKS protocol so that the packets can be correctly redirected at the other side of the tunnel.
O tráfego que passa por esta porta local será enviado para o host remoto. A partir daí, o protocolo SOCKS será interpretado para estabelecer uma conexão com o local final desejado. Essa configuração permite que um aplicativo compatível com SOCKS se conecte a qualquer número de locais por meio do servidor remoto, sem vários túneis estáticos.
Para estabelecer a conexão, passaremos a flag -D juntamente com a porta local onde desejamos acessar o túnel. Também usaremos a flag -f, que faz com que o SSH entre em segundo plano antes de executar, e a flag -N, que não abre um shell ou executa um programa no lado remoto.
Por exemplo, para estabelecer um túnel na porta 7777, você pode digitar:
A partir daqui, você pode começar a apontar seu aplicativo compatível com SOCKS (como um navegador da web) para a porta que você selecionou. O aplicativo enviará suas informações para um soquete associado à porta.
O método de direcionar o tráfego para a porta SOCKS irá diferir dependendo da aplicação. Por exemplo, no Firefox, a localização geral é Preferências > Avançado > Configurações > Configurações de proxy manual. No Chrome, você pode iniciar a aplicação com a flag --proxy-server= definida. Você vai querer usar a interface localhost e a porta que você encaminhou.
Como a conexão está em segundo plano, você terá que encontrar o PID para encerrá-la. Você pode fazer isso procurando pela porta que você encaminhou:
Output1001 5965 0.0 0.0 48168 1136 ? Ss 12:28 0:00 ssh -f -N -D 7777 username@remote_host
1001 6113 0.0 0.0 13648 952 pts/2 S+ 12:37 0:00 grep --colour=auto 8888
Você pode então encerrar o processo direcionando o PID, que é o número na segunda coluna, da linha que corresponde ao seu comando SSH:
Outra opção é iniciar a conexão sem a flag -f. Isso manterá a conexão em primeiro plano, impedindo você de usar a janela do terminal durante o encaminhamento. O benefício disso é que você pode encerrar o túnel facilmente digitando CTRL-C.
Usando Códigos de Escape SSH para Controlar Conexões
Mesmo depois de estabelecer uma sessão SSH, é possível exercer controle sobre a conexão de dentro do terminal. Podemos fazer isso com algo chamado códigos de escape SSH, que nos permitem interagir com nosso software SSH local de dentro de uma sessão.
Forçando uma Desconexão do Lado do Cliente (Como Sair de uma Sessão Travada ou Congelada)
Uma das características mais úteis do OpenSSH, que passa largamente despercebida, é a capacidade de controlar certos aspectos da sessão a partir do interior dela.
Esses comandos podem ser executados começando com o caractere de controle ~ dentro de uma sessão SSH. Os comandos de controle só serão interpretados se forem a primeira coisa digitada após uma nova linha, então sempre pressione ENTER uma ou duas vezes antes de usar um.
Um dos controles mais úteis é a capacidade de iniciar uma desconexão do cliente. As conexões SSH são normalmente encerradas pelo servidor, mas isso pode ser um problema se o servidor estiver com problemas ou se a conexão tiver sido interrompida. Ao usar uma desconexão do lado do cliente, a conexão pode ser encerrada limparmente pelo cliente.
Para fechar uma conexão do cliente, use o caractere de controle (~), com um ponto. Se sua conexão estiver com problemas, você provavelmente estará em uma sessão de terminal travada. Digite os comandos mesmo sem feedback para realizar uma desconexão do lado do cliente:
A conexão deve ser imediatamente encerrada, retornando você à sua sessão de shell local.
Colocando uma Sessão SSH em Segundo Plano
Uma das características mais úteis do OpenSSH que passa largamente despercebida é a capacidade de controlar certos aspectos da sessão a partir da conexão.
Esses comandos podem ser executados começando com o caractere de controle ~ de dentro de uma conexão SSH. Os comandos de controle só serão interpretados se forem a primeira coisa digitada após uma nova linha, então sempre pressione ENTER uma ou duas vezes antes de usar um.
Uma capacidade que isso proporciona é colocar uma sessão SSH em segundo plano. Para fazer isso, precisamos fornecer o caractere de controle (~) e então executar o atalho de teclado convencional para colocar uma tarefa em segundo plano (CTRL-z):
Isso colocará a conexão em segundo plano, retornando você à sua sessão de shell local. Para retornar à sua sessão SSH, você pode usar os mecanismos convencionais de controle de tarefas.
Você pode reativar imediatamente sua tarefa mais recente em segundo plano digitando:
Se você tiver várias tarefas em segundo plano, pode ver os trabalhos disponíveis digitando:
Output[1]+ Stopped ssh username@some_host
[2] Stopped ssh username@another_host
Você pode então trazer qualquer uma das tarefas para o primeiro plano usando o índice na primeira coluna com um sinal de porcentagem:
Alterando Opções de Encaminhamento de Porta em uma Conexão SSH Existente
Uma das características mais úteis do OpenSSH que passa em grande parte despercebida é a capacidade de controlar certos aspectos da sessão de dentro da conexão.
Esses comandos podem ser executados começando com o caractere de controle ~ de dentro de uma conexão SSH. Os comandos de controle só serão interpretados se forem a primeira coisa digitada após uma nova linha, então sempre pressione ENTER uma ou duas vezes antes de usá-los.
Uma coisa que isso permite é que um usuário altere a configuração de encaminhamento de porta após a conexão já ter sido estabelecida. Isso permite que você crie ou desative regras de encaminhamento de porta dinamicamente.
Essas capacidades fazem parte da interface de linha de comando do SSH, que pode ser acessada durante uma sessão usando o caractere de controle (~) e “C”:
ssh>
Você receberá um prompt de comando SSH, que tem um conjunto muito limitado de comandos válidos. Para ver as opções disponíveis, você pode digitar -h a partir deste prompt. Se nada for retornado, você pode ter que aumentar a verbosidade da saída do seu SSH usando ~v algumas vezes:
Commands:
-L[bind_address:]port:host:hostport Request local forward
-R[bind_address:]port:host:hostport Request remote forward
-D[bind_address:]port Request dynamic forward
-KL[bind_address:]port Cancel local forward
-KR[bind_address:]port Cancel remote forward
-KD[bind_address:]port Cancel dynamic forward
Como pode ver, pode facilmente implementar qualquer uma das opções de encaminhamento usando as opções apropriadas (consulte a seção de encaminhamento para mais informações). Também pode destruir um túnel com o comando associado “kill” especificado com um “K” antes da letra do tipo de encaminhamento. Por exemplo, para encerrar um encaminhamento local (-L), poderia usar o comando -KL. Apenas precisará fornecer a porta para isso.
Portanto, para configurar um encaminhamento de porta local, pode digitar:
A porta 8888 no seu computador local agora poderá comunicar com o servidor web no host ao qual está conectado. Quando terminar, pode desfazer esse encaminhamento digitando:
Conclusão
As instruções acima devem cobrir a maioria das informações que a maioria dos usuários precisará sobre SSH no dia a dia. Se tiver outras dicas ou desejar compartilhar suas configurações e métodos favoritos, sinta-se à vontade para usar os comentários abaixo.