security - script - Ocultar/cifrar la contraseña en el archivo bash para dejar de verla accidentalmente

gpg linux

Question

Disculpe si se ha preguntado esto 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 canalizarla en otros comandos en un archivo bash?

Me doy cuenta de que hacer esto no proporciona seguridad real, es más que evitar que alguien vea la contraseña accidentalmente si está viendo el script por encima de mi 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 ninguna manera, pero impide que alguien la vea accidentalmente por encima de mi hombro.

Answer 1

Aunque no se trata de una solución Unix incorporada, 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" se puede utilizar en configuraciones compatibles con POSIX. La descripción completa está disponible en el repositorio de github -> https://github.com/ahnick/encpass.sh . Esta solución generará automáticamente una clave para su script y almacenará la clave y su contraseña (u otros secretos) en un directorio oculto debajo de su usuario (es decir, ~ / .encpass).

En su script, solo necesita la fuente encpass.sh y luego llamar al método get_secret. Por ejemplo:

#!/bin/sh
. encpass.sh
password=$(get_secret)

Pegando el código para encpass.sh para una visibilidad más fácil:

#!/bin/sh
################################################################################
# Filename: encpass.sh
# Description: This script allows a user to encrypt a password (or any other
# secret) 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.
#
# This script generates an AES 256 bit symmetric key for each
# script (or user-defined label) that stores secrets. This key
# will then be used to encrypt all secrets for that script or
# label. encpass.sh sets up a directory (.encpass) under the
# user''s home directory where keys and secrets will be stored.
#
# Subsequent calls to retrieve a secret will not prompt for a
# secret to be entered as the file with the encrypted value
# already exists.
#
# Author: Xan Nick
#
# Usage: . ./encpass.sh
# ...
# $password=$(get_secret)
################################################################################
checks() {
if [ -n "$ENCPASS_CHECKS" ]; then
return
fi
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
ENCPASS_HOME_DIR=$(get_abs_filename ~)/.encpass
if [ ! -d $ENCPASS_HOME_DIR ]; then
mkdir -m 700 $ENCPASS_HOME_DIR
mkdir -m 700 $ENCPASS_HOME_DIR/keys
mkdir -m 700 $ENCPASS_HOME_DIR/secrets
fi
if [ ! -z $1 ] && [ ! -z $2 ]; then
LABEL=$1
SECRET_NAME=$2
elif [ ! -z $1 ]; then
LABEL=$(basename $0)
SECRET_NAME=$1
else
LABEL=$(basename $0)
SECRET_NAME="password"
fi
ENCPASS_CHECKS=1
}
generate_private_key() {
KEY_DIR="$ENCPASS_HOME_DIR/keys/$LABEL"
if [ ! -d $KEY_DIR ]; then
mkdir -m 700 $KEY_DIR
fi
if [ ! -f $KEY_DIR/private.key ]; then
(umask 0377 && printf "%s" "$(openssl rand -hex 32)" > $KEY_DIR/private.key)
fi
}
get_private_key_abs_name() {
PRIVATE_KEY_ABS_NAME="$ENCPASS_HOME_DIR/keys/$LABEL/private.key"
if [ ! -f "$PRIVATE_KEY_ABS_NAME" ]; then
generate_private_key
fi
}
get_secret_abs_name() {
SECRET_ABS_NAME="$ENCPASS_HOME_DIR/secrets/$LABEL/$SECRET_NAME.enc"
if [ ! -f "$SECRET_ABS_NAME" ]; then
set_secret $1 $2
fi
}
get_secret() {
checks $1 $2
get_private_key_abs_name
get_secret_abs_name $1 $2
dd if=$SECRET_ABS_NAME ibs=1 skip=32 2> /dev/null | openssl enc -aes-256-cbc /
-d -a -iv $(head -c 32 $SECRET_ABS_NAME) -K $(cat $PRIVATE_KEY_ABS_NAME)
}
set_secret() {
checks $1 $2
get_private_key_abs_name
SECRET_DIR="$ENCPASS_HOME_DIR/secrets/$LABEL"
if [ ! -d $SECRET_DIR ]; then
mkdir -m 700 $SECRET_DIR
fi
echo "Enter $SECRET_NAME:" >&2
stty -echo
read -r SECRET
stty echo
echo "Confirm $SECRET_NAME:" >&2
stty -echo
read -r CSECRET
stty echo
if [ "$SECRET" = "$CSECRET" ]; then
printf "%s" "$(openssl rand -hex 16)" > /
$SECRET_DIR/$SECRET_NAME.enc
echo "$SECRET" | openssl enc -aes-256-cbc -e -a -iv /
$(cat $SECRET_DIR/$SECRET_NAME.enc) -K /
$(cat $ENCPASS_HOME_DIR/keys/$LABEL/private.key) 1>> /
$SECRET_DIR/$SECRET_NAME.enc
else
echo "Error: secrets 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
}

Answer 2

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

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

Hay una manera más conveniente de almacenar contraseñas en un script, pero tendrá que cifrar y ofuscar el script para que no pueda leerse. Para cifrar y ofuscar con éxito un script de shell y hacer que ese script sea ejecutable, intente copiarlo y pegarlo 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 script y darle al script un nombre propio, luego presione 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 proporcionó. Luego, vaya a su casilla 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

Lo que el comando de instalación anterior hará por ti es:

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

NOTA:

Esto no funciona para los scripts interactivos que solicitan y esperan una respuesta del usuario. Los valores que se esperan del usuario deben estar codificados en el script. El cifrado garantiza que nadie pueda ver realmente esos valores, por lo que no debe preocuparse por eso.

RELACIÓN:

La solución provista en esta publicación responde a su problema en el sentido de que encripta el script real que contiene la contraseña que usted quería encriptar. Puede dejar la contraseña como está (sin cifrar), pero el script en el que se encuentra la contraseña está tan oculto y encriptado que puede estar seguro de que nadie podrá verla. Y si se intentan hacer palanca en el script, recibirá notificaciones por correo electrónico sobre ellos.

Answer 4

La siguiente línea en el código anterior no funciona

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

La línea correcta es:

DB_PASSWORD=`echo $PASSWORD|base64 -d`

Y guarda la contraseña en otro archivo como CONTRASEÑA.

Answer 5

OpenSSL proporciona un comando de passwd que puede cifrar pero no descifra ya que solo hace hashes. También puede descargar algo como aesutil para que pueda utilizar una rutina de cifrado simétrico capaz y bien 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 6

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

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

Primero encripta tu contraseña:

EDITAR : coloque un espacio antes de este comando, para que no esté registrado por el historial de bash.

echo -n "pAssw0rd" | gpg --armor --no-default-keyring --keyring /media/usb/key.pub --recipient [email protected] --encrypt

Se imprimirá la contraseña encriptada en gpg en la salida estándar. Copie el mensaje completo y agregue esto al script:

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 solo si el usb está montado en el sistema, la contraseña se puede descifrar. Por supuesto, también puede importar las claves en el sistema (menos seguro o sin seguridad) o puede proteger la clave privada con una contraseña (por lo que no puede automatizarse).

Answer 7

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

Esto es lo que hice: creé un nuevo archivo "db_auth.cfg" y creé parámetros con uno como mi contraseña de db. Puse el permiso como 750 para el archivo.

DB_PASSWORD=Z29vZ2xl

En mi script de shell usé el comando "source" para obtener el archivo y luego lo descodifiqué para usarlo en mi script.

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

Espero que esto ayude.

Answer 8

• sangra el borde de la pantalla (asumiendo que no usas ajuste de línea y tienes un ancho de editor consistente)

o

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