Como usar senhas criptografadas em scripts Bash

Se você for forçado a usar um script do Linux para se conectar a um recurso protegido por senha, provavelmente não se sentirá à vontade para inserir 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 pode fazer?

Você pode inserir a senha manualmente quando o processo chegar a esse ponto, mas se o script for executado de forma autônoma, isso não funcionará. Felizmente, há uma alternativa para codificar as senhas no script. Contra-intuitivamente, ele usa uma senha diferente para fazer isso, junto 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. Estaremos usando um script de shell Bash para fazer uma conexão SSH ao 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.

Faremos uso do conhecido  kit  de ferramentas OpenSSL para lidar com a criptografia e um utilitário chamado sshpasspara inserir a senha no comando SSH.

Instalando OpenSSL e sshpass

Como muitas outras ferramentas de criptografia e segurança usam OpenSSL, ele já pode estar instalado em seu computador. No entanto, se não for, a instalação leva apenas alguns instantes.

No Ubuntu, digite este comando:

sudo para obter o openssl

Para instalar sshpass, use este comando:

sudo apt install sshpass

No Fedora, você precisa digitar:

sudo dnf install openssl

O comando para instalar sshpassé:

sudo dnf install sshpass

No Manjaro Linux, podemos instalar o OpenSSL com:

sudo pacman -Sy openssl

Finalmente, para instalar sshpass, use este comando:

sudo pacman -Sy sshpass

Criptografando na linha de comando

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

Precisamos fornecer uma senha criptografada quando o fizermos. A senha de criptografia é usada nos processos de criptografia e descriptografia. Existem muitos parâmetros e opções no  openssl comando. 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 -salt -pass pass: 'pick.your.password'

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

Os opensslparâmetros são:

• enc -aes-256-cbc : O tipo de codificação. Estamos usando a cifra de chave de 256 bits do Advanced Encryption Standard com encadeamento de blocos de criptografia.
• -md sha512 : O tipo de resumo (hash) da mensagem. Estamos usando o algoritmo criptográfico SHA512.
• -a : Diz opensslpara aplicar a codificação de base 64 após a fase de criptografia e antes da fase de descriptografia.
• -pbkdf2 : O uso da função 2 de derivação de chave baseada em senha (PBKDF2) torna muito mais difícil para um ataque de força bruta adivinhar sua senha. 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 PBKDF2 usará.
• -salt : Usar um valor salt aplicado aleatoriamente torna a saída criptografada diferente a cada vez, mesmo se o texto simples for o mesmo.
• -pass pass: ‘pick.your.password’ : A senha que precisaremos usar para descriptografar a senha remota criptografada. Substitua pick.your.passwordpor uma senha robusta de sua escolha.

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

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

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

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

Isso prova que podemos criptografar com segurança a senha de 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, é verdade. Mas a senha criptografada da conta do usuário remoto será armazenada em um arquivo oculto diferente. As permissões no arquivo impedirão que qualquer pessoa exceto você – e o usuário root do sistema, obviamente – o acessem.

Para enviar a saída do comando de criptografia para um arquivo, podemos usar o redirecionamento. O arquivo é denominado “.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 -salt -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 cataqui, não echo.

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

A senha foi descriptografada com sucesso a partir dos dados do arquivo. Nós vamos usarchmod para alterar as permissões neste arquivo para que ninguém mais pode acessá-lo.

chmod 600 .secret_vault.txt

ls -l .secret_vault.txt

Usar 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 prosseguir escrevendo nosso roteiro.

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 -salt -pass pass: 'secret # vault! Senha')

# computador remoto
REMOTE_LINUX = fedora-34.local

# conecte-se ao computador remoto e coloque um carimbo de data / hora 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“geek”.
• Em seguida, definimos uma variável chamada REMOTE_PASSWDpara o valor da senha descriptografada retirada do arquivo “.secret_vault.txt”, usando o mesmo comando que usamos um momento atrás.
• A localização do computador remoto é armazenada em uma variável chamada REMOTE_LINUX.

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

• O sshpasscomando é o primeiro comando na linha de conexão. Nós o usamos com a -popção (senha). Isso nos permite especificar a senha que deve ser enviada ao sshcomando.
• Usamos a -Topção (desabilitar alocação de pseudo-terminal) com sshporque não precisamos ter um pseudo-TTY alocado para nós no computador remoto.

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

O comando enviado ao computador remoto simplesmente registra o nome da conta do 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 de seu próprio computador remoto, conta de usuário remoto e senha de conta remota.

Use chmodpara tornar o script executável.

chmod + x go-remote.sh

Só falta experimentar. Vamos iniciar 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 carimbos de data / hora.

cat script.log

Sua senha é privada

A senha da sua conta remota não é 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.