Ocultar contraseña/cifrar en el archivo bash para dejar de ver accidentalmente

Question

Lo siento si esto se ha hecho antes, comprobé pero no pude encontrar nada ...

¿Existe una función en Unix para cifrar y descifrar una contraseña en un archivo por lotes para que pueda canalizarlo en algunos otros comandos en un archivo bash?

que se dan cuenta de que al hacer esto no proporciona una seguridad real, es más para detener a alguien accidentalmente ver la contraseña si están buscando en el guión por encima del hombro :)

estoy corriendo en Red Hat 5.3.

Tengo un script que hace algo similar a esto:

serverControl.sh -u admin -p myPassword -c shutdown 

y me gustaría hacer algo como esto:

password = decrypt("fgsfkageaivgea", "aDecryptionKey") 
serverControl.sh -u admin -p $password -c shutdown 

Esto no protege la contraseña de cualquier manera, pero impide que alguien accidentalmente lo vea por encima de mi hombro.

Answer 1

OpenSSL proporciona un comando passwd que puede cifrar pero no descifrar, ya que sólo hace hashes . También puede descargar algo como aesutil para que pueda usar una rutina de cifrado simétrica capaz y conocida.

Por ejemplo:

#!/bin/sh  
# using aesutil 
SALT=$(mkrand 15) # mkrand generates a 15-character random passwd 
MYENCPASS="i/b9pkcpQAPy7BzH2JlqHVoJc2mNTBM=" # echo "passwd" | aes -e -b -B -p $SALT 
MYPASS=$(echo "$MYENCPASS" | aes -d -b -p $SALT) 

# and usage 
serverControl.sh -u admin -p $MYPASS -c shutdown 

Answer 2

Debería poder usar crypt, mcrypt o gpg para satisfacer sus necesidades. Todos ellos admiten una serie de algoritmos. crypt está un poco desactualizado.

Más información:

• http://manpages.ubuntu.com/manpages/lucid/man1/mcrypt.1.html
• http://mcrypt.sourceforge.net/
• http://linux.about.com/od/commands/l/blcmdl3_crypt.htm
• http://www.cyberciti.biz/tips/linux-how-to-encrypt-and-decrypt-files-with-a-password.html

Answer 3

• guión que fuera del borde de la pantalla (suponiendo que no se utiliza el ajuste de línea y tiene una anchura constante editor)

o

• guárdelo en un archivo aparte y léalo en.

Answer 4

Utilicé base64 para superar el mismo problema, es decir, las personas pueden ver mi contraseña por encima del hombro.

Esto es lo que hice - Creé un nuevo archivo "db_auth.cfg" y creé parámetros con uno de ellos era mi contraseña de db. Establecí el permiso como 750 para el archivo.

DB_PASSWORD=Z29vZ2xl 

En mi script de shell que utiliza el comando "fuente" para obtener el archivo y luego decodificar de nuevo a utilizar en mi guión.

source path_to_the_file/db_auth.cfg 
DB_PASSWORD=$(eval echo ${DB_PASSWORD} | base64 --decode) 

Espero que esto ayude.

Answer 5

línea siguiente en el código de seguridad no está funcionando

DB_PASSWORD=$(eval echo ${DB_PASSWORD} | base64 --decode) 

línea correcta es:

DB_PASSWORD=`echo $PASSWORD|base64 -d` 

Y guardar la contraseña en otro archivo como contraseña.

Answer 6

Hay una forma más conveniente de almacenar contraseñas en un script, pero deberá encriptar y ofuscar el script para que no se pueda leer. Con el fin de cifrar con éxito y ofuscar un script de shell y en realidad tienen ese guión sea ejecutable, intente copiar y pegar aquí:

http://www.kinglazy.com/shell-script-encryption-kinglazy-shieldx.htm

En la página anterior, todo lo que tiene que hacer es enviar su guión y dar el guion es un nombre propio, luego presiona el botón de descarga. Se generará un archivo zip para usted. Haga clic derecho en el enlace de descarga y copie la URL que se le proporciona. Luego, vaya a su cuadro UNIX y realice los siguientes pasos.

Instalación:

1. wget link-to-the-zip-file 
2. unzip the-newly-downloaded-zip-file 
3. cd /tmp/KingLazySHIELD 
4. ./install.sh /var/tmp/KINGLAZY/SHIELDX-(your-script-name) /home/(your-username) -force 

¿Qué comando lo anterior instalación va a hacer por ti es:

1. instalar la versión encriptada de la secuencia de comandos en el directorio/var/tmp/KINGLAZY/SHIELDX- (su-script-nombre).
2. Pondrá un enlace a este script encriptado en el directorio que especifique en reemplazo de/home/(su nombre de usuario), de esta manera, le permite acceder fácilmente al script sin tener que escribir la ruta absoluta.
3. Garantiza que NADIE puede modificar la secuencia de comandos: cualquier intento de modificar la secuencia de comandos cifrada la dejará inoperable ... hasta que se detengan o eliminen esos intentos. Incluso puede ser configurado para notificarlo cada vez que alguien intenta hacer algo con el script que no sea ejecutarlo ... es decir. intentos de piratería o modificación.
4. Garantiza absolutamente NADIE puede hacer copias de él. Nadie puede copiar su script en una ubicación aislada e intentar atornillarlo para ver cómo funciona. Todas las copias de la secuencia de comandos deben ser enlaces a la ubicación original que usted especificó durante la instalación (paso 4).

NOTA:

Esto no funciona para los scripts interactivos que le pide y espera a que el usuario de una respuesta. Los valores que se esperan del usuario deben estar codificados en el script. El cifrado asegura que nadie puede ver esos valores, por lo que no debe preocuparse por eso.

relación:

La solución proporcionada en este post responde a su problema en el sentido de que encripta el guión real que contiene la contraseña que quería tener cifrada. Puede dejar la contraseña como está (sin cifrar) pero la secuencia de comandos en la que se encuentra la contraseña está tan profundamente enmascarada y encriptada que puede estar seguro de que nadie podrá verla. Y si se realizan intentos para intentar abrir la secuencia de comandos, recibirá notificaciones por correo electrónico sobre ellos.

Answer 7

Otra solución, independientemente de la seguridad (también creo que es mejor mantener las credenciales en otro archivo o en una base de datos) es encriptar la contraseña con gpg e insertarla en el script.

Utilizo un par de llaves gpg sin contraseña que guardo en un usb. (Nota: cuando exporte este par de llaves, no use --armor, expórtelas en formato binario).

Primera cifrar su contraseña:

echo -n "pAssw0rd" | gpg --armor --no-default-keyring --keyring /media/usb/key.pub --recipient someone@mail.com --encrypt 

Eso será imprimir la contraseña de cifrado GPG en la salida estandar. Copiar todo el mensaje y añadir esto a la secuencia de comandos:

password=$(gpg --batch --quiet --no-default-keyring --secret-keyring /media/usb/key.priv --decrypt <<EOF 
-----BEGIN PGP MESSAGE----- 

hQEMA0CjbyauRLJ8AQgAkZT5gK8TrdH6cZEy+Ufl0PObGZJ1YEbshacZb88RlRB9 
h2z+s/Bso5HQxNd5tzkwulvhmoGu6K6hpMXM3mbYl07jHF4qr+oWijDkdjHBVcn5 
0mkpYO1riUf0HXIYnvCZq/4k/ajGZRm8EdDy2JIWuwiidQ18irp07UUNO+AB9mq8 
5VXUjUN3tLTexg4sLZDKFYGRi4fyVrYKGsi0i5AEHKwn5SmTb3f1pa5yXbv68eYE 
lCVfy51rBbG87UTycZ3gFQjf1UkNVbp0WV+RPEM9JR7dgR+9I8bKCuKLFLnGaqvc 
beA3A6eMpzXQqsAg6GGo3PW6fMHqe1ZCvidi6e4a/dJDAbHq0XWp93qcwygnWeQW 
Ozr1hr5mCa+QkUSymxiUrRncRhyqSP0ok5j4rjwSJu9vmHTEUapiyQMQaEIF2e2S 
/NIWGg== 
=uriR 
-----END PGP MESSAGE----- 
EOF) 

De esta manera si el USB está montado en el sistema de la contraseña puede ser descifrado. Por supuesto, también puede importar las claves en el sistema (menos seguro o sin seguridad) o puede proteger la clave privada con contraseña (para que no pueda ser automatizada).

Answer 8

Aunque esta solución no está integrada en Unix, he implementado una solución para esto utilizando un script de shell que se puede incluir en cualquier script de shell que esté utilizando. Este "debería" ser utilizable en configuraciones compatibles con POSIX. La descripción completa está disponible en el repositorio github ->https://github.com/ahnick/encpass.sh. Esta solución usará su clave pública SSH para firmar una contraseña creada por OpenSSL. Luego se puede descifrar usando su clave SSH privada.

pegar el código para encpass.sh para facilitar la visibilidad:

#!/bin/sh 
################################################################################ 
# Filename: encpass.sh 
# Description: This script allows a user to encrypt a password at runtime and 
#    then use it, decrypted, within another script. This prevents 
#    shoulder surfing passwords and avoids storing the password in 
#    plain text, which could inadvertently be sent to or discovered 
#    by an individual at a later date. By default, the SSH public key 
#    of the user is used to encrypt the user specified password. 
#    The encrypted password is stored in a file in the current 
#    directory. This file can then be decrypted to obtain the 
#    password using the user's SSH private key. Subsequent calls 
#    to get_password will not prompt for a password to be entered 
#    as the file with the encrypted password already exists. 
# 
# Author: Xan Nick 
# 
# Note: This assumes both public and private keys reside in the .ssh directory. 
#  You may pass a different directory to pull the keys from as an argument 
#  to the script. 
# 
# Usage: source ./encpass.sh 
#  ... 
#  $password=$(get_password) 
################################################################################ 

get_key_path() { 
    if [ ! -z $1 ]; then 
     get_abs_filename $1 
    else 
     get_abs_filename ~/.ssh 
    fi 
} 

get_password() { 
    if [ ! -x "$(command -v openssl)" ]; then 
     echo "Error: OpenSSL is not installed or not accessible in the current path. Please install it and try again." >&2 
     exit 1 
    fi 

    KEY_PATH=$(get_key_path $1) 

    if [ ! -d $KEY_PATH ]; then 
     echo "Error: KEY_PATH directory $KEY_PATH not found. Please check permissions and try again." >&2 
     exit 1 
    fi 

    # Create a PKCS8 version of the public key in the current directory if one does not already exist 
    if [ ! -z id_rsa.pub.pem ]; then 
     if [ ! -x "$(command -v ssh-keygen)" ]; then 
      echo "ssh-keygen is needed to generate a PKCS8 version of your public key. Please install it and try again." >&2 
     fi 

     ssh-keygen -f $KEY_PATH/id_rsa.pub -e -m PKCS8 > id_rsa.pub.pem 

     if [ ! -f id_rsa.pub.pem ]; then 
      echo "Failed to create PKCS8 version of the public key. Please check permissions and try again." >&2 
      exit 1 
     fi 
    fi 

    if [ ! -f pass.enc ]; then 
     set_password 
    fi 

    echo $(openssl rsautl -decrypt -ssl -inkey $KEY_PATH/id_rsa -in pass.enc) 
} 

set_password() { 
    echo "Enter your Password:" >&2 
    stty -echo 
    read PASSWORD 
    stty echo 
    echo "Confirm your Password:" >&2 
    stty -echo 
    read CPASSWORD 
    stty echo 
    if [ $PASSWORD == $CPASSWORD ]; then 
     echo $PASSWORD | openssl rsautl -encrypt -pubin -inkey id_rsa.pub.pem -out pass.enc 
    else 
     echo "Error: passwords do not match. Please try again." >&2 
     exit 1 
    fi 
} 

get_abs_filename() { 
    # $1 : relative filename 
    filename=$1 
    parentdir=$(dirname "${filename}") 

    if [ -d "${filename}" ]; then 
     echo "$(cd "${filename}" && pwd)" 
    elif [ -d "${parentdir}" ]; then 
    echo "$(cd "${parentdir}" && pwd)/$(basename "${filename}")" 
    fi 
}