Inicie ssh-agent al iniciar session

Tengo un sitio como un repository de Git remoto que extrae de Bitbucket.com con un alias de SSH. Puedo iniciar manualmente el ssh-agent en mi server, pero tengo que hacer esto cada vez que inicio session a través de SSH.

Comienzo manualmente el ssh-agent:

eval ssh-agent $SHELL 

Luego agrego el agente:

 ssh-add ~/.ssh/bitbucket_id 

Luego aparece cuando lo hago:

 ssh-add -l 

Y estoy listo para irme. ¿Hay alguna forma de automatizar este process para que no tenga que hacerlo cada vez que inicie session? El server ejecuta RedHat 6.2 (Santiago).

Por favor revisa este artículo. Puede encontrar esto muy útil:

http://mah.everybody.org/docs/ssh

En caso de que el enlace de arriba desaparezca algún día, estoy capturando la pieza principal de la solución a continuación:

Esta solución de Joseph M. Reagle por medio de Daniel Starin:

Agregue esto siguiente a su .bash_profile

 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 

Esta versión es especialmente buena ya que verá si ya ha iniciado ssh-agent y, si no puede encontrarlo, lo iniciará y almacenará las configuraciones para que puedan ser utilizadas la próxima vez que inicie una shell.

La solución aceptada tiene los siguientes inconvenientes:

  • es complicado de mantener;
  • evalúa el file de almacenamiento que puede conducir a errores o violación de security;
  • inicia el agente pero no lo detiene, lo que equivale a dejar la llave en ignición.

Si sus keys no requieren escribir la contraseña, sugiero seguir la solución. Agregue lo siguiente a su final .bash_profile (edite la list de keys según sus necesidades):

 exec ssh-agent $BASH -s 10<&0 << EOF ssh-add ~/.ssh/your_key1.rsa \ ~/.ssh/your_key2.rsa &> /dev/null exec $BASH <&10- EOF 

Tiene las siguientes ventajas:

  • solución mucho más simple;
  • la session del agente finaliza cuando termina la session de bash.

Tiene posibles desventajas:

  • El command interactivo ssh-add solo influirá en una session, que de hecho es un problema solo en circunstancias muy atípicas;
  • inutilizable si se requiere escribir la contraseña;
  • shell iniciado se convierte en no iniciar session (que no influye en nada AFAIK).

Tenga en count que varios processs de ssh-agent no son una desventaja, ya que no requieren más memory o time de CPU.

En Arch Linux, lo siguiente funciona realmente bien (debería funcionar en todas las distribuciones basadas en systemd):

Cree un service de usuario systemd, poniendo lo siguiente en ~/.config/systemd/user/ssh-agent.service :

 [Unit] Description=SSH key agent [Service] Type=forking Environment=SSH_AUTH_SOCK=%t/ssh-agent.socket ExecStart=/usr/bin/ssh-agent -a $SSH_AUTH_SOCK [Install] WantedBy=default.target 

Setup shell para tener una variable de entorno para el socket ( .bash_profile, .zshrc, ... ):

 export SSH_AUTH_SOCK="$XDG_RUNTIME_DIR/ssh-agent.socket" 

Habilite el service, por lo que se iniciará automáticamente al iniciar session y lo iniciará:

 systemctl --user enable ssh-agent systemctl --user start ssh-agent 

Agregue la siguiente configuration a su file de configuration ssh ~/.ssh/config (esto funciona desde SSH 7.2):

 AddKeysToAgent yes 

Esto le indicará al cliente ssh que siempre agregue la key a un agente en ejecución, por lo que no es necesario agregarlo de antemano.

Una vieja pregunta, pero encontré una situación similar. No piense que la respuesta anterior logra completamente lo que se necesita. La pieza faltante es keychain ; instálalo si aún no lo está.

 sudo apt-get install keychain 

A continuación, agregue la siguiente línea a su ~/.bashrc

 eval `keychain --eval id_[yourid file]` 

Esto iniciará el ssh-agent si no se está ejecutando, conéctese si lo hace, cargue las variables de entorno ssh-agent en su shell y cargue su key ssh.

Referencia

https://unix.stackexchange.com/questions/90853/how-can-i-run-ssh-add-automatically-without-password-prompt

Agregue esto a su ~/.bashrc :

 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 | grep "The agent has no identities" && ssh-add 

Esto solo debería solicitar una contraseña la primera vez que inicie session después de cada reinicio. Seguirá reutilizando el ssh-agent mientras siga funcionando.

Entonces solía usar los enfoques descritos anteriormente, pero prefiero que el agente muera cuando finaliza mi última session de bash. Esto es un poco más largo que las otras soluciones, pero es mi enfoque preferido. La idea básica es que la primera session bash inicie el ssh-agent. Luego, cada session adicional bash comtesting el file de configuration ( ~/.ssh/.agent_env ). Si está ahí y hay una session ejecutándose, proceda con el entorno y cree un enlace fijo al file de socket en /tmp (debe estar en el mismo sistema de files que el file de socket original). A medida que se cierran las sesiones bash, cada una borra su propio enlace permanente. La última session para cerrar encontrará que los enlaces duros tienen 2 enlaces (el enlace fijo y el original), la eliminación del propio socket del process y la eliminación del process dará como resultado 0, dejando un entorno limpio después de que se cierre la última session de bash.

 # Start ssh-agent to keep you logged in with keys, use `ssh-add` to log in agent=`pgrep ssh-agent -u $USER` # get only your agents if [[ "$agent" == "" || ! -e ~/.ssh/.agent_env ]]; then # if no agents or environment file is missing create a new one # remove old agents / environment variable files kill $agent running rm ~/.ssh/.agent_env # restart eval `ssh-agent` echo 'export SSH_AUTH_SOCK'=$SSH_AUTH_SOCK >> ~/.ssh/.agent_env echo 'export SSH_AGENT_PID'=$SSH_AGENT_PID >> ~/.ssh/.agent_env fi # create our own hardlink to the socket (with random name) source ~/.ssh/.agent_env MYSOCK=/tmp/ssh_agent.${RANDOM}.sock ln -T $SSH_AUTH_SOCK $MYSOCK export SSH_AUTH_SOCK=$MYSOCK end_agent() { # if we are the last holder of a hardlink, then kill the agent nhard=`ls -l $SSH_AUTH_SOCK | awk '{print $2}'` if [[ "$nhard" -eq 2 ]]; then rm ~/.ssh/.agent_env ssh-agent -k fi rm $SSH_AUTH_SOCK } trap end_agent EXIT set +x 

Perdón por llegar tan tarde:

Los usuarios de la concha de pez pueden usar esta secuencia de commands para hacer lo mismo.

 # content has to be in .config/fish/config.fish # if it does not exist, create the file setenv SSH_ENV $HOME/.ssh/environment function start_agent echo "Initializing new SSH agent ..." ssh-agent -c | sed 's/^echo/#echo/' > $SSH_ENV echo "succeeded" chmod 600 $SSH_ENV . $SSH_ENV > /dev/null ssh-add end function test_identities ssh-add -l | grep "The agent has no identities" > /dev/null if [ $status -eq 0 ] ssh-add if [ $status -eq 2 ] start_agent end end end if [ -n "$SSH_AGENT_PID" ] ps -ef | grep $SSH_AGENT_PID | grep ssh-agent > /dev/null if [ $status -eq 0 ] test_identities end else if [ -f $SSH_ENV ] . $SSH_ENV > /dev/null end ps -ef | grep $SSH_AGENT_PID | grep -v grep | grep ssh-agent > /dev/null if [ $status -eq 0 ] test_identities else start_agent end end 

Lo resolví agregando esto a / etc / profile – system wide (o al usuario local .profile, o .bash_profile).

 # SSH-AGENT #!/usr/bin/env bash SERVICE='ssh-agent' WHOAMI=`who am i |awk '{print $1}'` if pgrep -u $WHOAMI $SERVICE >/dev/null then echo $SERVICE running. else echo $SERVICE not running. echo starting ssh-agent > ~/.ssh/agent_env fi . ~/.ssh/agent_env 

Esto inicia un nuevo ssh-agent si no se ejecuta para el usuario, o restablece el parámetro de env de ssh-agent si se está ejecutando.

Me gustan mucho tus respuestas. Hizo mucho más fácil trabajar desde hosts cygwin / linux . Combiné las funciones de inicio y fin para asegurarlo.

 SSH_ENV="$HOME/.ssh/.agent_env" function start_agent { echo "Initialising new SSH agent..." eval `/usr/bin/ssh-agent` echo 'export SSH_AUTH_SOCK'=$SSH_AUTH_SOCK >> ${SSH_ENV} echo 'export SSH_AGENT_PID'=$SSH_AGENT_PID >> ${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 # create our own hardlink to the socket (with random name) MYSOCK=/tmp/ssh_agent.${RANDOM}.sock ln -T $SSH_AUTH_SOCK $MYSOCK export SSH_AUTH_SOCK=$MYSOCK end_agent() { # if we are the last holder of a hardlink, then kill the agent nhard=`ls -l $SSH_AUTH_SOCK | awk '{print $2}'` if [[ "$nhard" -eq 2 ]]; then rm ${SSH_ENV} /usr/bin/ssh-agent -k fi rm $SSH_AUTH_SOCK } trap end_agent EXIT set +x 

gracias de nuevo

Solo para agregar otra solución: P, fui con una combinación de las soluciones de @spheenik y @ collin-anderson.

  # Ensure that we have an ssh config with AddKeysToAgent set to true if [ ! -f ~/.ssh/config ] || ! cat ~/.ssh/config | grep AddKeysToAgent | grep yes > /dev/null; then echo "AddKeysToAgent yes" >> ~/.ssh/config fi # Ensure a ssh-agent is running so you only have to enter keys once 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 

Podría ser un poco más elegante pero simple y legible. Esta solución:

  • asegura que AddKeysToAgent yes está en su configuration de ssh así que las keys se agregarán automáticamente al usarlas
  • no le solicita que ingrese ninguna frase de contraseña al iniciar session (de nuevo, la contraseña de una sola vez ingresa al primer uso)
  • inicia silenciosamente un ssh-agent si aún no ha comenzado uno

Comentarios bienvenidos 🙂