Existe uma maneira de passar dados confidenciais no bash usando um prompt, para qualquer comando?

Idealmente, você nunca digita uma senha de texto não criptografado na linha de comando como um argumento para um comando. Fazer isso torna a senha um argumento para o comando, e os argumentos da linha de comando podem ser vistos na tabela de processos usando ferramentas simples como psou registrados em alguns logs de auditoria.

Dito isto, certamente existem maneiras de ocultar a senha real do histórico de comandos do shell.

sha1pass "$( head -n 1 )"

Em seguida, digite a senha e pressione Enter. O headcomando usado aqui aceita exatamente uma linha de entrada e a última nova linha que você digitar não fará parte dos dados que são passados ​​para sha1pass.

Para evitar que os caracteres ecoem:

sha1pass "$( stty -echo; head -n 1; stty echo )"

O stty -echocomando desativa o eco dos caracteres digitados no terminal. O eco é então restaurado com stty echo.

Para transmitir a entrada padrão, esse último comando pode ser alterado (você teria feito isso se sha1passaceitasse dados na entrada padrão, mas aparece como se este utilitário específico estivesse ignorando sua entrada padrão):

{ stty -echo; head -n 1; stty echo; } | somecommand

Se você precisar de entrada de várias linhas (o acima assume que uma única linha deve ser passada, sem caractere de nova linha no final), substitua todo o headcomando cate encerre a entrada (supondo que somecommandele seja lido até o final do arquivo) com Ctrl+D( seguinte Returnse desejar incluir um caractere de nova linha na entrada ou duas vezes se não quiser).

Isso funcionaria independentemente do shell que você estivesse usando (desde que fosse um shell do tipo Bourne ou rc).

Alguns shells podem ser feitos para não salvar os comandos digitados em seus arquivos de histórico se o comando for precedido por um espaço. Isso geralmente envolve ter que definir HISTCONTROLo valor ignorespace. Isso é suportado pelo menos por bashe kshno OpenBSD, mas não por, por exemplo, ksh93ou dash. zshos usuários podem usar a histignorespaceopção ou sua HISTORY_IGNOREvariável para definir um padrão a ser ignorado.

Em shells que suportam leitura readsem ecoar caracteres para o terminal, você também pode usar

IFS= read -rs password     # -s turns off echoing in bash or zsh
                           # -r for reading backslashes as-is,
                           # IFS= to preserve leading and trailing blanks
sha1pass "$password"

mas isso obviamente ainda tem o mesmo problema com a revelação potencial da senha na tabela de processos.

Se o utilitário ler da entrada padrão e se o shell suportar "here-strings", o acima poderá ser alterado para

IFS= read -rs password
somecommand <<<"$password"

Resumo dos comentários abaixo:

• A execução de um comando com uma senha fornecida na linha de comando, que todos os comandos acima fazem, exceto aquele que canaliza os dados para o comando, tornará a senha potencialmente visível para qualquer pessoa executando psao mesmo tempo. No entanto, nenhum dos comandos acima salvará a senha digitada no arquivo de histórico do shell se executado a partir de um shell interativo.

• Programas bem comportados que lêem senhas de texto não criptografado fazem isso lendo de sua entrada padrão, de um arquivo ou diretamente do terminal.

• sha1passrequer a senha na linha de comando, digitada diretamente ou usando alguma forma de substituição de comando.

• Se possível, use outra ferramenta.

Se você definir HISTCONTROLassim:

HISTCONTROL=ignorespace

e inicie o comando com um espaço:

~$  mycommand

não será armazenado no histórico.

Se estiver usando o shell zshou bash, use a opção -s para o readshell integrado para ler uma linha do dispositivo terminal sem que ela seja repetida.

IFS= read -rs VARIABLE < /dev/tty

Então você pode usar algum redirecionamento sofisticado para usar a variável como stdin.

sha1pass <<<"$VARIABLE"

Se alguém executar ps, tudo o que verá é "sha1pass".

Isso pressupõe que sha1passlê a senha do stdin (em uma linha, ignorando o delimitador de linha) quando não recebe nenhum argumento.

Passe dados confidenciais por meio de um pipe ou here-doc:

command_with_secret_output | command_with_secret_input

ou:

command_with_secret_input <<EOF
$secret
EOF

É bom que os segredos estejam em variáveis ​​de shell (não exportadas), mas você nunca pode usar essas variáveis ​​em linhas de comando, apenas em here-documents e shell internals.

Conforme observado por Kusalananda em um comentário, se você estiver inserindo comandos em um shell interativo, as linhas inseridas para um documento here serão armazenadas no histórico do shell, portanto, não é seguro digitar uma senha lá, mas ainda deve ser seguro usar variáveis ​​shell contendo segredos; o histórico conterá o texto $secretem vez de qualquer coisa $secretexpandida.

O uso de expansões de comando não é seguro :

command_with_secret_input "$(command_with_secret_output)"

porque a saída será incluída na linha de comando e visível na pssaída (ou leitura manual de /proc), exceto em sistemas com /proc endurecido.

A atribuição a uma variável também é aceitável:

secret=$(command_with_secret_output)

Basta escrever o valor em um arquivo e passar o arquivo:

$ cat > mysecret
Big seecreeeet!
$ cat mysecret | sha1pass 

Não tenho certeza de como sha1passfunciona, se puder receber um arquivo como entrada, você pode usar sha1pass < mysecret. Caso contrário, usar catpode ser um problema, pois inclui a nova linha final. Se for esse o caso, use (se o seu headsuporte -c):

head -c-1 mysecret | sha1pass 

Se o que o terdon fez for possível, então essa é a melhor solução, passando pela entrada padrão. O único problema que resta é que ele escreveu a senha no disco. Podemos fazer isso em vez disso:

stty -echo
echo -n "password: "
head -1 | sha1pass
stty echo

Como Kusalananda disse, stty -echogarante que o que você digita não seja visto até que você o faça stty echonovamente. head -1obterá uma linha da entrada padrão e a passará para sha1pass.

eu usaria

sha1pass "$(cat)"

catleria de stdin até EOF, o que pode ser causado pressionando Ctrl+D. Então, o resultado seria passado como argumento parasha1pass

Se você está passando informações confidenciais e as usa regularmente, provavelmente é melhor criptografá-las.

Colocando algo como

#create key as follows - will prompt for password
#echo -n 'secret you want encrypted' | openssl enc -aes-256-cbc  -a -salt -pbkdf2|base64
export MY_SECRET='VTJGc2RHVmtYMTlzVnBGWXNYUitLWlpYT3BWdStaQXJXeUVwc1JORnFsNWswZXJKT1dkRWpsWkxLWVFnK1hONQo='

Em seu .bashrc, você terá uma variável de ambiente criptografada que você pode acessar sempre que precisar de um segredo, e será solicitada a senha/senha que você usou ao criar a variável de ambiente.

No exemplo acima é 'secret'

Você acessa é um comando da seguinte forma

`echo $MY_SECRET|base64 --decode|openssl enc -aes-256-cbc -a -d -salt -pbkdf2 `

por exemplo

xfreerpd /parameters.... /p:`echo $MY_SECRET|base64 --decode|openssl enc -aes-256-cbc -a -d -salt -pbkdf2` 

Para sua consulta usando sha1pass. Você pode criar e passar da seguinte forma

MY_SECRET=`echo -n 'secret you want encrypted' | openssl enc -aes-256-cbc  -a -salt -pbkdf2|base64`

Então use da seguinte forma

sha1pass `echo $MY_SECRET|base64 --decode|openssl enc -aes-256-cbc -a -d -salt -pbkdf2 `

A parte base64 é para que você possa definir a variável

MY_SECRET='VTJGc2RHVmtYMTlzVnBGWXNYUitLWlpYT3BWdStaQXJXeUVwc1JORnFsNWswZXJKT1dkRWpsWkxLWVFnK1hONQo='

E não deixe seu segredo preso no histórico de comandos etc etc.

Quando você gera o segredo, às vezes, a saída base64 terá várias linhas, então você precisa fazer as quebras de linha para sua variável.

echo -n 'secret you want encrypted' | openssl enc -aes-256-cbc  -a -salt -pbkdf2|base64
enter aes-256-cbc encryption password:
Verifying - enter aes-256-cbc encryption password:
VTJGc2RHVmtYMTlzVnBGWXNYUitLWlpYT3BWdStaQXJXeUVwc1JORnFsNWswZXJKT1dkRWpsWkxL
WVFnK1hONQo=

#take the above line break out 
MY_SECRET='VTJGc2RHVmtYMTlzVnBGWXNYUitLWlpYT3BWdStaQXJXeUVwc1JORnFsNWswZXJKT1dkRWpsWkxLWVFnK1hONQo='

O openssh solicitará uma senha para criptografar e descriptografar a cada vez, você pode fornecer uma como parte do comando, mas estará apenas ocultando coisas do histórico, etc. Dê uma olhada em https://www.tecmint.com/ generate-encrypt-decrypt-random-passwords-in-linux/ para obter algumas informações sobre como usar o openssh para isso. https://www.serverlab.ca/tutorials/linux/administration-linux/how-to-base64-encode-and-decode-from-command-line/ para base64 e https://stackoverflow.com/questions/16072351 /how-to-assign-an-output-to-a-shellscript-variable para diferentes opções na substituição de comando que usei back-tick ` acima