Como gerar e gerenciar chaves SSH no Linux

O protocolo SSH (Secure Shell) fornece a capacidade de executar comunicações criptografadas sobre redes de computadores. Operações típicas que podemos executar usando o protocolo são execuções de login remoto e comando remoto. Quando fazemos login em um computador remoto (com o ssh utilitário, por exemplo), somos solicitados a fornecer a senha para a conta que estamos usando para fazer login. Para uma segurança aprimorada, podemos decidir usar as teclas SSH como credenciais: depois que o servidor SSH estiver configurado adequadamente, para poder fazer login, precisamos saber algo (a senha), mas também possuir algo (uma chave). Neste tutorial, vemos como gerar, gerenciar e usar as teclas SSH.

Neste tutorial, você aprenderá:

• O que é um SSH Keypir
• Qual é a diferença entre uma chave SSH pública e privada e qual é o seu papel
• Como gerar teclados ssh
• Como modificar a senha de uma chave SSH privada
• Como transferir chaves públicas para um servidor SSH

Requisitos de software e convenções usadas

Como funcionam os teclados ssh

As teclas SSH são usadas como credenciais de login, geralmente no lugar de senhas simples de texto transparente. Eles trabalham em pares: sempre temos um público e a privado chave. A chave privada deve permanecer no computador local que atua como o cliente: é usado para descriptografar informação e nunca devem ser compartilhadas. A chave pública, por outro lado, é usada para criptografar dados e deve ser copiada no servidor remoto (seu conteúdo é copiado no ~/.ssh/autorizado_keys Arquivo no Diretório Home $ do Usuário que login como no servidor - veremos como executar essa operação no decorrer deste tutorial).

A capacidade de usar o SSH-KEYS como credenciais de login deve ser permitido no lado do servidor pelo administrador do sistema, definindo o PubKeyauthentication opção para sim no /etc/ssh/sshd.Config arquivo. As senhas de texto claro e as chaves públicas podem ser permitidas como métodos de autenticação ao mesmo tempo, ou, por exemplo, pode -se decidir permitir o acesso apenas por meio de chaves públicas.

As ferramentas e utilitários que usaremos neste tutorial são instalados por padrão em todas as principais distribuições Linux, como parte do suíte de software OpenSSH.

Gerando um SSH Keypir

Gerar um SSH KEYYPAIR é uma operação muito simples: tudo o que precisamos fazer é usar o ssh-keygen Utilitário. A maneira mais fácil de executar a operação é apenas invocar o comando sem nenhum argumento ou opção:

$ ssh-keygen generating público/privado RSA Par de chave. Digite o arquivo para salvar a chave (/home/egdoc/.SSH/ID_RSA): Digite a senha (vazia sem senha): Digite a mesma frase novamente: Sua identificação foi salva em/home/egdoc/.ssh/id_rsa Sua chave pública foi salva em/home/egdoc/.ssh/id_rsa.Pub A principal impressão digital é: SHA256: JRCJ3A3EQ4WO/LX4VACCPCKYEAYU0AI80EMCDA7M5DK EGDOC@fingolfin A imagem Randomart da chave é: + --- [RSA 3072] ---- + | =.+.o . | | * = O… | | E… o + . | | . o+. o + .| | OS. + o.| | o + o.+ O | | . o.ob.o… | | o .B.B . | | +… Oo = . | +---- [SHA256]-----+ 

Vamos analisar o que acontece ao invocar o comando dessa maneira. A primeira coisa que nos pedem é onde as chaves geradas devem ser armazenadas: por padrão, a chave privada gerada é chamada id_rsa, e o nome do público é obtido adicionando o .bar extensões para isso. Ambos, por padrão, são criados dentro do ~/.ssh diretório; Somos livres, no entanto, para fornecer nomes e localização alternativos.

A segunda coisa que somos solicitados é fornecer um senha: é usado para proteger a chave privada. Podemos entrar na senha ou apenas pressionar Enter e deixar o campo em branco. No primeiro caso, seremos solicitados a fornecer a senha que usamos cada vez que tentamos usar a chave. Se deixarmos o campo vazio, em vez disso, podemos obter um login sem senha no servidor: isso pode representar um risco de segurança, pois todos com acesso à chave podem facilmente nos personificar; Por outro lado, essa configuração geralmente é usada para executar operações não assistidas via SSH, como, por exemplo, backups programados.

Depois de fornecer uma senha, as chaves são geradas e as Impressão digital chave e imagem aleatória são exibidos na tela. Está feito! Neste ponto, temos nosso teclado ssh no lugar.

Alterar o tipo de chave e o tamanho do bit

Por padrão, quando nenhuma opção específica é passada para o ssh-keygen comando, an RSA O par de teclas é gerado com um tamanho de 3072 bits. Para usar um tipo de chave alternativo, devemos usar o -t opção de ssh-keygen e forneça o tipo de chave que queremos usar como argumento. Os tipos de chave disponíveis são:

• DSA
• Ecdsa
• Ecdsa-SK
• ED25519
• ED25519-SK
• RSA

Cada tipo de chave tem seu padrão no tamanho do bit. DSA Keys, por exemplo, deve ser exatamente de 1024 Bits, enquanto para as teclas Ecdsa, conforme declarado no manual:

-B Sinalizador determina o comprimento da chave selecionando de um dos tamanhos da curva elípticos: 256, 384 ou 521 bits.

Outros tipos-chave como Ecdsa-SK, ED25519 e ED25519-SK têm um comprimento fixo que não pode ser alterado.

Sempre que possível, para alterar o tamanho do bit que deve ser usado para a geração de chaves, podemos usar o -b opção do ssh-keygen utilidade e passar o número de tamanho de bit como seu argumento. Digamos que queremos gerar uma chave RSA de 4096 bits (em vez do padrão 3072); nós funcionaríamos:

$ ssh -keygen -b 4096 

Especifique o caminho das chaves não interativamente

Como vimos no exemplo, quando não especificado de outra forma, o nome padrão usado para as chaves geradas será id_rsa. É claro que podemos mudar isso de forma interativa, quando solicitada, mas e se quisermos fornecê -lo de antemão? Bem, nesse caso, podemos invocar ssh-keygen junto com o -f opção, e passe o nome do arquivo para usar para a chave como seu argumento. Suponha que queremos que nossas chaves sejam armazenadas como ~/.SSH/LinuxConfig_RSA (privado) e ~/.SSH/LinuxConfig_RSA.bar (público);
nós funcionaríamos:

$ ssh -keygen -f ~//.SSH/LinuxConfig_RSA 

Alterar uma senha de chave privada

Como já vimos, quando criamos um SSH Keypir, temos a chance de proteger a chave privada com uma senha que podemos fornecer quando solicitado. E se quisermos modificar esta senha em algum momento no futuro? Como podemos mudar a senha de uma chave privada?

É fácil! Tudo o que precisamos fazer é invocar o ssh-keygen utilidade com o -p opção. Quando invocarmos o comando com esta opção, primeiro seremos solicitados a fornecer o caminho da chave privada que queremos mudar, então seremos solicitados a fornecer a senha antiga usada para ela (se houver) e, finalmente, seremos pediu para entrar na nova senha duas vezes:

$ ssh -keygen -p Enter o arquivo no qual a chave é (/home/egdoc/.SSH/ID_RSA): Digite anha antiga: Key tem comentar "Digite a nova senha (vazia sem senha): Digite a mesma senha novamente: Sua identificação foi salva com a nova senha. 

A chave padrão que será selecionada para mudança de senha é ~/.ssh/id_rsa, Assim como acontece no momento da criação. Se queremos fornecer o caminho de uma chave privada direta e não interativa, podemos, novamente, usar o -f opção e passar
O caminho principal como argumento, por exemplo:

$ ssh -keygen -p -f ~//.ssh/id_rsa 

Carregando a chave pública no servidor

Para poder usar as teclas SSH que geramos como método de autenticação em um servidor remoto, precisamos fazer upload de nossa chave pública nele. O conjunto de ferramentas OpenSSH fornece um utilitário que é projetado especificamente para executar esta tarefa:
SSH-COPY-ID. Aqui está um exemplo de seu uso. Para copiar a tecla SSH padrão id_rsa.bar Em um servidor remoto, nós executaríamos:

$ SSH-COPY-ID -I ~//.ssh/id_rsa.pub [email protected] 

O que fizemos no exemplo acima é bem simples. Invocamos o SSH-COPY-ID utilidade com o -eu Opção: Esta opção vamos especificar a chave pública que deve ser usada. Passamos sua chave de caminho como o argumento da opção (o .bar o sufixo é adicionado automaticamente se não estiver presente). O principal argumento que fornecemos é, em vez disso, o usuário que queremos fazer login (opcional) junto com o endereço IP do servidor.

A saída do comando acima será algo semelhante ao seguinte:

/usr/bin/ssh-copy-id: informações: fonte de chave (s) a ser instalada: "/home/egdoc/.ssh/id_rsa.pub "/usr/bin/ssh-copy-id: informações: tentando fazer login com a nova (s) chave (s), para filtrar os que já estão instalados/usr/bin/ssh-copy-id: info: 1 chave (s) permanecem instalados - se você for solicitado agora, é para instalar as novas chaves [email protected] de 39: 

Para que a chave seja instalada no servidor SSH, devemos primeiro fornecer a senha atual que estamos usando para fazer o login. Depois de fazê -lo, se tudo correr como o esperado, veremos a seguinte resposta:

Número de chaves adicionadas: 1 Agora tente fazer login na máquina, com: "ssh '[email protected] '"e verifique se apenas as chaves que você queria foram adicionadas. 

Se não tivermos certeza sobre quais chaves seriam copiadas no servidor remoto, podemos lançar SSH-COPY-ID com o -n opção para executar um funcionamento a seco: As chaves não serão instaladas no servidor; Em vez disso, os que seriam copiados serão relatados na tela.

A porta padrão usada pelo servidor SSH é 22; Às vezes, o administrador do sistema, no entanto, pode decidir mudá -lo, apenas para evitar os ataques de força bruta mais genérica. Nesses casos, quatro nossa conexão SSH ao trabalho, devemos usar o -p (abreviatura de --porta) opção ao invocar o SSH-COPY-ID comando e passe a porta que deve ser usada para a conexão como seu argumento. Supondo que a porta usada seja 15342, Por exemplo, nós funcionaríamos:

SSH-COPY-ID -I ~//.ssh/id_rsa.Pub -P 15342 [email protected] 

Conclusões

Neste tutorial, aprendemos o básico das chaves ssh: vimos que um par de teclas também é composto por uma chave pública e privada, para que são usadas e como elas devem ser tratadas. Vimos como gerar um teclado, quais são os diferentes tipos de chaves que podemos usar e como podemos especificar seu tamanho em bits no momento da criação. Também vimos como uma chave privada SSH pode ser protegida por uma senha e como podemos alterá -la. Finalmente aprendemos como podemos usar o SSH-COPY-ID utilidade para copiar uma chave pública especificada no servidor de destino.

Tutoriais do Linux relacionados:

• Uma introdução à automação, ferramentas e técnicas do Linux
• Coisas para instalar no Ubuntu 20.04
• Como configurar um servidor OpenVPN no Ubuntu 20.04
• Mastering Bash Script Loops
• Como gerenciar conexões sem fio usando o IWD no Linux
• Mint 20: Melhor que o Ubuntu e o Microsoft Windows?
• Linux pode obter vírus? Explorando a vulnerabilidade do Linux…
• Coisas para fazer depois de instalar o Ubuntu 20.04 fossa focal linux
• Sistema Linux Hung? Como escapar para a linha de comando e…
• Lista de clientes FTP e instalação no Ubuntu 22.04 Linux…