Como usar senhas criptografadas em scripts Bash

Se você for forçado a usar um script Linux para se conectar a um recurso protegido por senha, provavelmente se sentirá desconfortável em colocar essa senha no script. O OpenSSL resolve esse problema para você.

Senhas e scripts

Não é uma boa ideia colocar senhas em scripts de shell. Na verdade, é uma péssima ideia. Se o script cair em mãos erradas, todos que o lerem poderão ver qual é a senha. Mas se você for forçado a usar um script, o que mais você pode fazer?

Você pode inserir a senha manualmente quando o processo atingir esse ponto, mas se o script for executado sem supervisão, isso não funcionará. Felizmente, há uma alternativa para codificar as senhas no script. Contraintuitivamente, ele usa uma senha diferente para conseguir isso, juntamente com alguma criptografia forte.

Em nosso cenário de exemplo, precisamos fazer uma conexão remota a um computador Fedora Linux a partir de nosso computador Ubuntu. Usaremos um script de shell Bash para fazer uma conexão SSH com o computador Fedora. O script deve ser executado sem supervisão e não queremos colocar a senha da conta remota no script. Não podemos usar chaves SSH neste caso, porque estamos fingindo que não temos nenhum controle ou direitos de administrador sobre o computador Fedora.

Vamos fazer uso do conhecido kit de ferramentas OpenSSL para lidar com a criptografia e um utilitário chamado sshpass para alimentar a senha no comando SSH.

RELACIONADO: Como criar e instalar chaves SSH do shell do Linux

Instalando OpenSSL e sshpass

Como muitas outras ferramentas de criptografia e segurança usam OpenSSL, talvez ele já esteja instalado em seu computador. No entanto, se não for, leva apenas um momento para instalar.

No Ubuntu, digite este comando:

 sudo apt get openssl 

Para instalar sshpass , use este comando:

 sudo apt instalar sshpass 

No Fedora, você precisa digitar:

 sudo dnf instalar openssl 

O comando para instalar o sshpass é:

 sudo dnf instalar sshpass 

No Manjaro Linux, podemos instalar o OpenSSL com:

 sudo pacman -Sy openssl 

Finalmente, para instalar o sshpass , use este comando:

 sudo pacman -Sy sshpass 

Criptografando na linha de comando

Antes de começarmos a usar o comando openssl com scripts, vamos nos familiarizar com ele usando-o na linha de comando. Digamos que a senha da conta no computador remoto esteja rusty!herring.pitshaft . Vamos criptografar essa senha usando openssl .

Precisamos fornecer uma senha de criptografia quando o fizermos. A senha de criptografia é usada nos processos de criptografia e descriptografia. Existem muitos parâmetros e opções no comando openssl . Vamos dar uma olhada em cada um deles em um momento.

 echo 'enferrujado!herring.pitshaft' | openssl enc -aes-256-cbc -md sha512 -a -pbkdf2 -iter 100000 -sal -pass pass:'pick.your.password' 

Estamos usando o echo para enviar a senha da conta remota por meio de um pipe e para o comando openssl .

Os parâmetros openssl são:

• enc -aes-256-cbc : O tipo de codificação. Estamos usando a criptografia de chave Advanced Encryption Standard de 256 bits com encadeamento de bloco de cifra.
• -md sha512 : O tipo de resumo da mensagem (hash). Estamos usando o algoritmo criptográfico SHA512.
• -a : Isso diz ao openssl para aplicar a codificação base-64 após a fase de criptografia e antes da fase de descriptografia.
• -pbkdf2 : Usar a Função 2 de derivação de chave baseada em senha (PBKDF2) torna muito mais difícil para um ataque de força bruta conseguir adivinhar sua senha. O PBKDF2 requer muitos cálculos para realizar a criptografia. Um invasor precisaria replicar todos esses cálculos.
• -iter 100000 : Define o número de cálculos que o PBKDF2 usará.
• -salt : Usar um valor salt aplicado aleatoriamente torna a saída criptografada sempre diferente, mesmo que o texto simples seja o mesmo.
• -pass pass:'pick.your.password' : A senha que precisaremos usar para descriptografar a senha remota criptografada. Substitua pick.your.password por uma senha robusta de sua escolha.

A versão criptografada de nossa senha rusty!herring.pitshaft é gravada na janela do terminal.

Para descriptografar isso, precisamos passar essa string criptografada para openssl com os mesmos parâmetros que usamos para criptografar, mas adicionando a opção -d (decrypt).

 echo U2FsdGVkX19iiiRNhEsG+wm/uKjtZJwnYOpjzPhyrDKYZH5lVZrpIgo1S0goZU46 | openssl enc -aes-256-cbc -md sha512 -a -d -pbkdf2 -iter 100000 -sal -pass pass:'pick.your.password' 

A string é descriptografada e nosso texto original — a senha da conta de usuário remoto — é gravado na janela do terminal.

Isso prova que podemos criptografar com segurança a senha da nossa conta de usuário remoto. Também podemos descriptografá-lo quando precisarmos usando a senha que fornecemos na fase de criptografia.

Mas isso realmente melhora nossa situação? Se precisarmos da senha de criptografia para descriptografar a senha da conta remota, certamente a senha de descriptografia precisará estar no script? Bem, sim, ele faz. Mas a senha da conta de usuário remoto criptografada será armazenada em um arquivo oculto diferente. As permissões no arquivo impedirão que qualquer pessoa além de você – e o usuário root do sistema, obviamente – acessem.

Para enviar a saída do comando de criptografia para um arquivo, podemos usar o redirecionamento. O arquivo é chamado “.secret_vault.txt”. Alteramos a senha de criptografia para algo mais robusto.

 echo 'enferrujado!herring.pitshaft' | openssl enc -aes-256-cbc -md sha512 -a -pbkdf2 -iter 100000 -sal -pass pass:'secret#vault!password' > .secret_vault.txt 

Nada visível acontece, mas a senha é criptografada e enviada para o arquivo “.secret_vault.txt”.

Podemos testar se funcionou descriptografando a senha no arquivo oculto. Observe que estamos usando cat aqui, não echo .

 cat .secret_vault.txt | openssl enc -aes-256-cbc -md sha512 -a -d -pbkdf2 -iter 100000 -sal -pass pass:'secret#vault!password' 

A senha é descriptografada com sucesso dos dados no arquivo. Usaremos chmod para alterar as permissões deste arquivo para que ninguém mais possa acessá-lo.

 chmod 600 .secret_vault.txt

 ls -l .secret_vault.txt 

O uso de uma máscara de permissões de 600 remove todo o acesso de qualquer pessoa que não seja o proprietário do arquivo. Agora podemos passar a escrever nosso script.

RELACIONADO: Como usar o comando chmod no Linux

Usando OpenSSL em um script

Nosso script é bastante simples:

 #!/bin/bash

# nome da conta remota
REMOTE_USER=geek

# senha para a conta remota
REMOTE_PASSWD=$(cat .secret_vault.txt | openssl enc -aes-256-cbc -md sha512 -a -d -pbkdf2 -iter 100000 -sal -pass pass:'secret#vault!password')

# computador remoto
REMOTE_LINUX=fedora-34.local

# conecte-se ao computador remoto e coloque um timestamp em um arquivo chamado script.log
sshpass -p $REMOTE_PASSWD ssh -T $REMOTE_USER@$REMOTE_LINUX << _remote_commands
echo $USER "-" $(data) >> /home/$REMOTE_USER/script.log
_remote_commands

• Definimos uma variável chamada REMOTE_USER como “geek”.
• Em seguida, definimos uma variável chamada REMOTE_PASSWD para o valor da senha descriptografada extraída do arquivo “.secret_vault.txt”, usando o mesmo comando que usamos há pouco.
• A localização do computador remoto é armazenada em uma variável chamada REMOTE_LINUX .

Com essas informações, podemos usar o comando ssh para conectar ao computador remoto.

• O comando sshpass é o primeiro comando na linha de conexão. Usamos com a opção -p (senha). Isso nos permite especificar a senha que deve ser enviada ao comando ssh .
• Usamos a opção -T (desativar alocação de pseudo-terminal) com ssh porque não precisamos ter um pseudo-TTY alocado para nós no computador remoto.

RELACIONADO Como usar "Aqui Documentos" no Bash no Linux

Estamos usando um pequeno documento aqui para passar um comando para o computador remoto. Tudo entre as duas strings _remote_commands é enviado como instruções para a sessão do usuário no computador remoto — nesse caso, é uma única linha de script Bash.

O comando enviado ao computador remoto simplesmente registra o nome da conta de usuário e um carimbo de data/hora em um arquivo chamado “script.log”.

Copie e cole o script em um editor e salve-o em um arquivo chamado “go-remote.sh”. Lembre-se de alterar os detalhes para refletir o endereço do seu próprio computador remoto, conta de usuário remoto e senha da conta remota.

Use chmod para tornar o script executável.

 chmod +x go-remote.sh 

Tudo o que resta é experimentá-lo. Vamos acionar nosso script.

 ./go-remote.sh 

Como nosso script é um modelo minimalista para um script autônomo, não há saída para o terminal. Mas se verificarmos o arquivo “script.log” no computador Fedora, podemos ver que as conexões remotas foram feitas com sucesso e que o arquivo “script.log” foi atualizado com timestamps.

 gato script.log 

Sua senha é privada

A senha da sua conta remota não está registrada no script.

E embora a senha de descriptografia esteja, no script, ninguém mais pode acessar seu arquivo “.secret_vault.txt” para descriptografá-lo e recuperar a senha da conta remota.