¿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 de agregar algunas líneas al bash_profilearchivo, pero aún necesito escribir la contraseña cada vez que reinicio / inicio de sesión en una máquina específica.

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

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_profileautomáticamente iniciará ssh-agenty cargará las claves 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-agentsolicita la frase de contraseña independientemente de si la clave se usará o no durante la sesión de inicio de sesión. Cada nuevo inicio de sesión también genera una ssh-agentinstancia 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 matar ssh_agental 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 para ~/.bash_profile

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

ssh-agentSe puede evitar la creación de varias instancias creando un socket de comunicación persistente con el agente en una ubicación fija en el sistema de archivos, como en la 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 Gnome Keyring , pueden ser un mejor enfoque, ya que generalmente se pueden hacer para solicitar la frase de contraseña la primera vez que se usa la clave ssh durante una sesión de inicio de sesión y almacenar 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-identes una utilidad que puede administrar ssh-agenten 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 desde el que 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 habilitarlo ssh-ident, instálelo y agregue el siguiente alias a su ~/bash_profile:

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

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

keychaines una pequeña utilidad que gestiona ssh-agenten su nombre y permite ssh-agentque siga ejecutándose cuando finaliza la sesión de inicio de sesión. En inicios de sesión posteriores, keychainse conectará a la ssh-agentinstancia existente . 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 inicios de sesión posteriores, ssh-agentse utiliza la clave no cifrada de la instancia existente . Esto también puede ser útil para permitir la autenticación RSA / DSA cronsin contraseña en trabajos sin claves ssh sin contraseña.

Para habilitarlo 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-identy keychainson peores que las ssh-agentinstancias limitadas a la vida útil de una sesión en particular, pero ofrecen un alto nivel de conveniencia. Para mejorar la seguridad de keychain, algunas personas agregan la --clearopción a su ~/.bash_profileinvocación de llavero. Al hacer esto, las frases de contraseña se deben volver a ingresar al iniciar sesión como se indicó anteriormente, pero los crontrabajos seguirán teniendo acceso a las claves no cifradas después de que el usuario cierre sesión. La keychain página wiki tiene más información y ejemplos.

ssh-key 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.

ssh-key con frase de contraseña, con ssh-agent , pasando la frase de contraseña al ssh-add script

Si bien puede parecer una idea sencilla pasar la frase de contraseña ssh-addde un guión, por ejemplo echo "passphrase\n" | ssh-add, esto no es tan sencillo como parece ssh-add que no lee la frase de contraseña stdin, sino que se abre /dev/ttydirectamente para leer .

Esto puede ser trabajado en torno a 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 expectscript 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.

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. Continuará reutilizando lo mismo ssh-agentmientras siga ejecutándose.

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 AddKeysToAgenty puede ser ajustado en yes, no, ask, o confirm, en todo el sistema o en su personal .ssh/configde archivos.

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

ssh-agent almacena en caché varias claves ssh desbloqueadas, por lo que puede 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.

Una vez dicho todo esto, simplemente puede usar claves ssh que no estén protegidas con contraseña (presione Entercuando se le solicite una contraseña durante la generación de claves). Como no hay ninguna contraseña, ssh-agentno es necesario que le pida una para (no) almacenarla en caché.

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 para evitar 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 enfoque de tubería con nombre :

  1. Cree una tubería con nombre (también puede intentar una sustitución de proceso ):

     mkfifo --mode 0600 ~/.ssh_fifo
     

  2. Ejecute ssh-addespecificando 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-addpara leer más sobre SSH_ASKPASS.

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 la sub-shell de la sección ssh-agent, con todos los archivos de claves agregados automáticamente, y 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 una 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. Luego, cuando lo ssh-add keyfile1 keyfile2 ...haga, solo tendrá que 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)

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

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

Trabajando zshsolo en shell.

#!/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

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

Dando 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

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 maquinas. Esta guía lo guiará a través de la configuración de esto.

No he verificado que esto realmente funcione.

Agregue esto a su ~/.bashrcarchivo:

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

Para agregar una clave (posiblemente sin contraseña) y asegurarse de que ssh-addno solicite una contraseña, pase lo que pase, incluso cuando se ejecuta bajo X :

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

El estado de salida indica éxito o fracaso.

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 en la que el seahorse hace un poco de caballito de mar para agregar magia, creo) ), y ofrece la OPCIÓN para desbloquear la clave al iniciar sesión, debe marcar 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.

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="$@"

# 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

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).

Mi configuración en macOS es la siguiente (en .zshrc, o .bash_profilepara 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

La || [[ $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_SOCKsiempre se establece en algo.

Luego en .zlogout(o .bash_logoutpara gente de bash):

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

Probado en macOS Mojave 10.14.5