desarrollo-web-br-bd.com

¿Cómo puedo ejecutar ssh-add automáticamente, sin una solicitud de contraseña?

Quiero comunicarme entre varias computadoras en mi red (Ethernet estática), a través de SSH. Para hacerlo, necesito ejecutar ssh-add cada vez que inicio sesión en una máquina específica, ¿cómo puedo hacerlo para que se configure una vez y no me pida la frase de contraseña cada vez que inicie sesión o reinicie? mi maquina

Sé que hay una manera en que deberías agregar algunas líneas a la bash_profile archivo, pero aún necesito escribir la contraseña cada vez que reinicio/inicio sesión en una máquina específica.

if [ -z "$SSH_AUTH_SOCK" ] ; then
    eval `ssh-agent -s`
    ssh-add
fi
267
zdun8

Este es un ejemplo típico de una compensación entre seguridad y conveniencia. Afortunadamente hay una serie de opciones. La solución más adecuada depende del escenario de uso y del nivel de seguridad deseado.

ssh-key con frase de contraseña, no ssh-agent

Ahora se debe ingresar la frase de contraseña cada vez que se usa la clave para la autenticación. Si bien esta es la mejor opción desde el punto de vista de la seguridad, ofrece la peor usabilidad. Esto también puede llevar a que se elija una frase de contraseña débil para disminuir la carga de ingresarla repetidamente.

ssh-key con frase de contraseña, con ssh-agent

Agregar lo siguiente a ~/.bash_profile Iniciará automáticamente ssh-agent Y cargará la (s) clave (s) ssh al iniciar sesión:

if [ -z "$SSH_AUTH_SOCK" ] ; then
  eval `ssh-agent -s`
  ssh-add
fi

Ahora se debe ingresar la frase de contraseña en cada inicio de sesión. Aunque es un poco mejor desde una perspectiva de usabilidad, esto tiene el inconveniente de que ssh-agent Solicita la frase de contraseña independientemente de si la clave se va a usar o no durante la sesión de inicio de sesión. Cada nuevo inicio de sesión también genera una instancia ssh-agent Distinta que permanece ejecutándose con las claves agregadas en la memoria incluso después de cerrar sesión, a menos que se elimine explícitamente.

Para eliminar ssh_agent Al cerrar sesión, agregue lo siguiente a ~/.bash_logout

if [ -n "$SSH_AUTH_SOCK" ] ; then
  eval `/usr/bin/ssh-agent -k`
fi

o lo siguiente a ~/.bash_profile

trap 'test -n "$SSH_AUTH_SOCK" && eval `/usr/bin/ssh-agent -k`' 0

La creación de múltiples instancias ssh-agent Se puede evitar creando un socket de comunicación persistente con el agente en una ubicación fija en el sistema de archivos, como en respuesta de Collin Anderson . Sin embargo, esta es una mejora con respecto a la generación de instancias de múltiples agentes, a menos que se elimine explícitamente la clave descifrada que aún permanece en la memoria después del cierre de sesión.

En los escritorios, los agentes ssh incluidos con el entorno de escritorio, como el Agente SSH de Gnome Keyring , pueden ser un mejor enfoque, ya que generalmente se pueden hacer que soliciten la frase de contraseña la primera vez que la clave ssh se usa durante una sesión de inicio de sesión y almacena la clave privada descifrada en la memoria hasta el final de la sesión.

ssh-key con frase de contraseña, con ssh-ident

ssh-ident es una utilidad que puede administrar ssh-agent En su nombre y cargar identidades según sea necesario. Agrega claves solo una vez, ya que son necesarias, independientemente de la cantidad de terminales, ssh o sesiones de inicio de sesión que requieren acceso a un ssh-agent. También puede agregar y usar un agente diferente y un conjunto diferente de claves dependiendo del Host al que se está conectando, o se invoca el directorio ssh. Esto permite aislar claves cuando se utiliza el reenvío de agentes con diferentes hosts. También permite usar varias cuentas en sitios como GitHub.

Para habilitar ssh-ident, Instálelo y agregue el siguiente alias a su ~/bash_profile:

alias ssh='/path/to/ssh-ident'

tecla ssh con frase de contraseña, con keychain

keychain es una pequeña utilidad que administra ssh-agent en su nombre y permite que ssh-agent permanezca ejecutándose cuando finaliza la sesión de inicio de sesión. En inicios de sesión posteriores, keychain se conectará a la instancia existente ssh-agent. En la práctica, esto significa que la frase de contraseña debe ingresarse solo durante el primer inicio de sesión después de un reinicio. En los inicios de sesión posteriores, se utiliza la clave no cifrada de la instancia existente ssh-agent. Esto también puede ser útil para permitir la autenticación RSA/DSA sin contraseña en cron trabajos sin claves ssh sin contraseña.

Para habilitar keychain, instálelo y agregue algo como lo siguiente a ~/.bash_profile:

eval `keychain --agents ssh --eval id_rsa`

Desde un punto de vista de seguridad, ssh-ident Y keychain son peores que las instancias ssh-agent Limitadas a la duración de una sesión en particular, pero ofrecen un alto nivel de conveniencia. Para mejorar la seguridad de keychain, algunas personas agregan la opción --clear A su invocación de llavero ~/.bash_profile. Al hacer esto, las frases de contraseña se deben volver a ingresar al iniciar sesión como se indicó anteriormente, pero los trabajos cron aún tendrán acceso a las claves no cifradas después de que el usuario cierre sesión. El keychainpágina wiki tiene más información y ejemplos.

clave ssh sin frase de contraseña

Desde el punto de vista de la seguridad, esta es la peor opción ya que la clave privada está completamente desprotegida en caso de que quede expuesta. Sin embargo, esta es la única forma de asegurarse de que la frase de contraseña no necesite volver a introducirse después de un reinicio.

clave ssh con frase de contraseña, con ssh-agent, pasando la frase de contraseña a ssh-add del script

Si bien puede parecer una idea sencilla pasar la frase de contraseña a ssh-add Desde un script, p. echo "passphrase\n" | ssh-add, Esto no es tan sencillo como parece como ssh-addno lee la frase de contraseña de stdin, pero abre /dev/tty Directamente para leer .

Esto puede ser solucionado con expect , una herramienta para automatizar aplicaciones interactivas. A continuación se muestra un ejemplo de un script que agrega una clave ssh utilizando una frase de contraseña almacenada en el script:

#!/usr/bin/expect -f
spawn ssh-add /home/user/.ssh/id_rsa
expect "Enter passphrase for /home/user/.ssh/id_rsa:"
send "passphrase\n";
expect "Identity added: /home/user/.ssh/id_rsa (/home/user/.ssh/id_rsa)"
interact

Tenga en cuenta que, dado que la frase de contraseña se almacena en texto sin formato en el script, desde una perspectiva de seguridad, esto es apenas mejor que tener una clave ssh sin contraseña. Si se va a utilizar este enfoque, es importante asegurarse de que el script expect que contiene la frase de contraseña tenga los permisos adecuados establecidos, por lo que solo el propietario de la clave puede leerlo, escribirlo y ejecutarlo.

363
Thomas Nyman

Agregue esto a su ~/.bashrc, luego cierre sesión y vuelva a entrar para que surta efecto.

if [ ! -S ~/.ssh/ssh_auth_sock ]; then
  eval `ssh-agent`
  ln -sf "$SSH_AUTH_SOCK" ~/.ssh/ssh_auth_sock
fi
export SSH_AUTH_SOCK=~/.ssh/ssh_auth_sock
ssh-add -l > /dev/null || ssh-add

Esto solo debe solicitar una contraseña la primera vez que inicie sesión después de cada reinicio. Seguirá reutilizando lo mismo ssh-agent mientras se mantenga en ejecución.

101
Collin Anderson

No está estrechamente relacionado con la pregunta del OP, pero podría ser útil para otros: dado que 7.2.0 ssh (1) tiene una opción que permite agregar una clave a ssh-agent en la primera autenticación; la opción es AddKeysToAgent y se puede establecer en yes, no, ask o confirm, en todo el sistema o en su cuenta personal .ssh/config archivo.

Referencia: https://www.openssh.com/txt/release-7.2

16
Guilherme Salazar

ssh-agent almacena en caché varias claves ssh desbloqueadas, para que pueda tener las claves ssh protegidas por contraseñas, pero sin tener que escribirlas cada vez.

Para almacenar en caché las claves desbloqueadas, obviamente necesita desbloquear esas claves. Para desbloquear claves que están bloqueadas con una frase de contraseña, obviamente necesita conocer estas frases de contraseña.

Cualquier método que no requiera autorización de un ser humano (por ejemplo, "escribir una contraseña") no solo hará que su sistema sea inseguro; también hará que todo el propósito del agente ssh no tenga sentido.

Habiendo dicho todo esto, simplemente puede usar las teclas ssh que no están protegidas con contraseña (presione Enter cuando se le solicita una contraseña durante la generación de claves). Como no hay ninguna contraseña, ssh-agent no necesita pedirle uno para (no) almacenarlo en caché.

7
umläute

Aquí hay una solución para automatizar su frase de contraseña SSH.

  1. Cree un script de una línea que imprima su frase de contraseña en la salida estándar, por ejemplo:

     echo 'echo MY_SSH_PASSWORD' > ~/.print_ssh_password && chmod 700 ~/.print_ssh_password
    

    Importante: asegúrese de copiar el espacio inicial a evite almacenar su contraseña en su historial .

Y use uno de los siguientes métodos.

  • utilizando un enfoque de entrada estándar:

    cat ~/.ssh/id_rsa | SSH_ASKPASS=~/.print_ssh_password ssh-add -
    
  • o canalización con nombre enfoque:

    1. Cree un canalización con nombre (también puede intentar un sustitución de proceso ):

      mkfifo --mode 0600 ~/.ssh_fifo
      
    2. Correr ssh-add especificando el programa utilizado para la autenticación:

      cat ~/.ssh/id_rsa >~/.ssh_fifo | SSH_ASKPASS=~/.print_ssh_password ssh-add ~/.ssh_fifo
      

    Ver: man ssh-add para leer más sobre SSH_ASKPASS.

5
kenorb

No le recomendaré ssh-add (que necesita abrir un agente ssh) al iniciar sesión. Esto se debe a que no puede controlar cuándo finaliza la sección ssh-agent y puede crear riesgos de seguridad cuando no necesita usar los archivos de claves en una sección de inicio de sesión.

Por el contrario, recomiendo escribir un script que abra una sección del sub-Shell de ssh-agent, con todos los archivos de claves agregados automáticamente, y que se lo llame cuando sea necesario para usar ssh. Si pudieras adoptarlo, sigue leyendo.

Tendrías dos opciones:

  1. Elimine todas las frases de contraseña de sus claves, que tienen seguridad débil si sus archivos de claves son robados. (por lo tanto no recomendado )

  2. Use la misma frase de contraseña para sus claves. Entonces cuando ssh-add keyfile1 keyfile2 ..., solo necesitará escribir la frase de contraseña una vez, por sección.

En ambos casos, puede escribir el archivo de script "ssh_keys_section.sh" como se muestra a continuación:

#!/bin/bash
# This script run a ssh-agent on a sub-Shell and automatically ssh-add all keyfiles at once.
# This agent ends when you type `exit` to close the sub-Shell.
exec ssh-agent bash -c "ssh-add /path/to/keyfile1 /path/to/keyfile2 ...; exec bash"

Observaciones:

  • Comando para cambiar o eliminar la frase de contraseña: ssh-keygen -p -f keyfile
  • Dentro del subconjunto, incluso puede bifurcar más terminales que comparten las mismas teclas desbloqueadas, utilizando quizás un comando como /path/to/yourterminal & (depende del sistema operativo)
4
Johnny Wong

Solía ​​usar la secuencia de comandos mencionada por steampowered, hice la siguiente ahora, porque no deja archivos por ahí.

Trabajando en zsh Shell solamente.

#!/bin/sh

AGENT_BIN=`which ssh-agent`
AGENT_ADD_BIN=`which ssh-add`
AGENT_PID=`ps -fe | grep ${AGENT_BIN} | awk -vuser=$USER -vcmd="$AGENT_BIN" '$1==user && $8==cmd{print $2;exit;}'`
if [ -z "$AGENT_BIN" ]; then
    echo "no ssh agent found!";
    return
fi
if [ "" -eq "$AGENT_PID" ]; then
    if read -sq "YN?Do you want to unlock your ssh keys?"; then
        echo ""
        output=`$AGENT_BIN | sed 's/echo/#echo/g'`
        eval $output
        $AGENT_ADD_BIN
    fi
else
    for f in "/proc/"*
    do
        cmdline=`cat "$f/cmdline"`
        if [ "${AGENT_BIN}" -ef "${cmdline}" ]; then
            export SSH_AUTH_SOCK=`cat $f/net/unix | grep --binary-file=text -oP '((/[^/]*?)+/ssh-[^/]+/agent\.\d+$)'`
            export SSH_AGENT_PID=${f##*/}
            break;
        fi
    done
fi
2
rmc
if [ ! -S ${HOME}/.ssh/ssh_auth_sock ]; then
  eval $(ssh-agent)
  ln -sf "${SSH_AUTH_SOCK}" ${HOME}/.ssh/ssh_auth_sock
fi
export SSH_AUTH_SOCK=${HOME}/.ssh/ssh_auth_sock

ssh_keys=$(find -E ~/.ssh -type f -regex '.*(rsa$|pem)')
ssh_agent_keys=$(ssh-add -l | awk '{key=NF-1; print $key}')

for k in "${ssh_keys}"; do
    for l in "${ssh_agent_keys}"; do
        if [[ ! "${k}" = "${l}" ]]; then
            ssh-add "${k}" > /dev/null 2>&1
        fi
    done
done

La solución de inicio de sesión único para SSH podría llevarme a pam_ssh .

Según este artículo , el concepto es:

Si trabaja con varias máquinas basadas en * nix a través de ssh, probablemente esté cansado de tener que ingresar constantemente su contraseña cada vez que desee acceder a otro cuadro. Hay una forma segura de permitirle acceder a todas las máquinas, a las que tiene acceso ssh, sin tener que ingresar otra contraseña (que no sea la que inició sesión originalmente).


En realidad, esto es bastante simple de hacer, básicamente solo crea un par de claves pública/privada para autenticarse en sus otras máquinas, luego hace que PAM genere un agente para cargar sus claves después de iniciar sesión, proporcionando una solución de inicio de sesión único para acceder a todos sus controles remotos máquinas. Esta guía lo guiará a través de la configuración de esto.

No he verificado que esto realmente funcione.

1
Michael
SSH_ENV="$HOME/.ssh/environment"

function start_agent {
     echo "Initialising new SSH agent..."
     /usr/bin/ssh-agent | sed 's/^echo/#echo/' > "${SSH_ENV}"
     echo succeeded
     chmod 600 "${SSH_ENV}"
     . "${SSH_ENV}" > /dev/null
     /usr/bin/ssh-add;
}

# Source SSH settings, if applicable

if [ -f "${SSH_ENV}" ]; then
     . "${SSH_ENV}" > /dev/null
     #ps ${SSH_AGENT_PID} doesn't work under cywgin
     ps -ef | grep ${SSH_AGENT_PID} | grep ssh-agent$ > /dev/null || {
         start_agent;
     }
else
     start_agent;
fi

Dar crédito aquí: https://www.cygwin.com/ml/cygwin/2001-06/msg00537.html

Esta solución también está respaldada aquí: http://mah.everybody.org/docs/ssh

1
steampowered

Agregue esto a su ~/.bashrc archivo:

ssh-add -L|grep identities > /dev/null && ssh-add /path/to/ssh/private/key
0
Abukamel

Aquí está el guión definitivo.

Actualice $ PASSW, luego cópielo y péguelo en su Terminal

# <sshpass> via typinator
# Updated: 2017-01-18_21h36
#
# apt-get update -y; apt-get install expect -qy

# Pass this value to ssh-add
PASSW="myfancypass123"

# Define a name for this script
THIS_SCRIPT="$(date +%Y-%m-%d_%H-%M-%S-%N)".sh

# Create a fresh directory to work from / Clean up
rm -rf ~/temp; mkdir -p ~/temp; cd ~/temp; ls -la


# Output our bash script file - BEGIN
cat <<< '
#!/bin/bash

set -u     # Stop if an unbound variable is referenced
set -e     # Stop on first error
export HISTIGNORE="expect*";

# Normal CMDs
echo && echo "The process should take about 10 seconds:" && echo
eval "$(ssh-agent -s)"; sleep 0.5;

# Define VAR passed when this bash-script was launched
password="[email protected]"

# Launch the expect magic
expect -c "
    spawn ssh-add /root/.ssh/id_rsa
    expect "?assword:"
    send \"$password\r\"
    expect "?password:"
    send \"$password\r\"
    expect eof"

export HISTIGNORE="";
export password="";
' > $THIS_SCRIPT
# Output our bash script file - END


# Ensure we are in the right path
cd ~/temp; ls -la; sleep 1;

# Run the bash script
chmod +x ./$THIS_SCRIPT; ./$THIS_SCRIPT "$PASSW"; unset password;

# Clean up
rm -rf ~/temp; mkdir -p ~/temp; cd ~/temp; ls -la
0
Pascal Andy

Para agregar una clave (posiblemente sin contraseña) y asegurarse de que ssh-add no solicitará una contraseña, pase lo que pase, incluso cuando se ejecute con X :

DISPLAY= ssh-add -k /path/to/key </dev/null &>/dev/null

El estado de salida indica éxito o fracaso.

0
Keith Cascio

La mejor manera que conozco es usar un script de inicio de sesión PAM que adapté del trabajo anterior porque no pude encontrar una respuesta satisfactoria en esta pregunta.

Su frase de contraseña se almacena cifrada con la contraseña de su sistema y una función de derivación pesada. Al iniciar sesión, la contraseña de su sistema se utiliza para descifrar su frase de contraseña y agregarla al agente.

https://github.com/capocasa/systemd-user-pam-ssh

La ventaja sobre cualquier otra solución presentada es que combina seguridad equivalente a ejecutar ssh-add manualmente en el arranque sin esfuerzo. No requiere herramientas adicionales y tiene una dependencia adicional que ya está instalada por defecto en la mayoría de los sistemas (OpenSSL).

0
cmc

Si está ejecutando seahorse como su administrador de contraseñas ... Lo que probablemente sea; D

Otra solución que logra el objetivo que está buscando es simplemente agregar las claves ssh a seahorse para el desbloqueo automático al iniciar sesión. El principal beneficio de esto es que nunca tiene que ingresar una contraseña para las claves después de iniciar sesión a través de gdm, o lo que sea que esté iniciando sesión incluso si las claves tienen una contraseña. Esto REQUIERE tanto la clave privada como la clave pública. También DEBEN seguir una convención de nomenclatura para caballitos de mar. El valor predeterminado es aceptable (id_rsa para clave privada e id_rsa.pub para clave pública ... Realmente cualquier cosa que sea privatekeyname y privatekeyname.pub )

Para agregar su clave ssh a seahorse para desbloqueo automático al iniciar sesión; (en Fedora25, no estoy seguro de dónde está la ruta en otras distribuciones, aunque probablemente sea muy similar)

/lib64/seahorse/seahorse-ssh-askpass /path/to/keys/here

Para mí fue

/lib64/seahorse/seahorse-ssh-askpass ~/.ssh/id_rsa

(Seahorse asumirá automáticamente que la clave pública en mi caso era id_rsa.pub)

Después de ejecutar el comando, seahorse abrirá un pequeño y lindo campo de contraseña gtk para ingresar la contraseña de la clave privada. o simplemente déjelo en blanco si generó la clave sin contraseña.

Seahorse no te avisará si todo salió bien. Deberá intentar ingresar a la máquina de destino. Luego, seahorse le pedirá que desbloquee la clave con una contraseña gráficamente (ESTO SÓLO OCURRIRÁ UNA VEZ) nuevamente, pero esta vez debería verse un poco diferente; P (esta es también la parte donde el seahorse hace un poco de caballito de mar para agregar magia, creo) ), y ofrezca la opción [~ # ~] [~ # ~] para desbloquear la clave al iniciar sesión, debe marque esta opción para lograr su objetivo.

Solo porque no leí todas las respuestas, recomendaría deshacer lo que todos te dijeron que hicieras con ssh-add antes de intentar esta respuesta. Hacerlo de otra manera podría resultar en que algo malo le suceda a tus llaves, idk.

0
enconn

Mi configuración en macOS es la siguiente (en .zshrc o .bash_profile para gente bash):

# Kill then Load the ssh-agent and set the necessary env variables it outputs
sshRestart() {
    # if all else fails
    # pkill -u $(whoami) ssh-agent;

    if [ -n "$SSH_AUTH_SOCK" ] ; then
        eval `/usr/bin/ssh-agent -k`
    fi
    eval `ssh-agent -s`
    ssh-add ~/.ssh/YOUR_KEY_FILE
    echo "Restarted SSH agent"
}

if [ -z "$SSH_AUTH_SOCK" ] || [[ $SSH_AUTH_SOCK == *"/private/tmp/"* ]] ; then
    eval `ssh-agent -s` > /dev/null 2>&1
    ssh-add ~/.ssh/YOUR_KEY_FILE > /dev/null 2>&1
fi

Los || [[ $SSH_AUTH_SOCK == *"/private/tmp/"* ]] parte es necesaria en macOS porque el valor predeterminado es /private/tmp/com.Apple.launchd.SOMETHINGHERE/Listeners. De lo contrario, la respuesta integral de @Thomas Nyman falla porque $SSH_AUTH_SOCK siempre se establece en algo.

Luego en .zlogout (o .bash_logout para gente bash):

if [ -n "$SSH_AUTH_SOCK" ] ; then
    eval `/usr/bin/ssh-agent -k`
fi

Probado en macOS Mojave 10.14.5

0
Samuel Prevost