Compartir el mismo `ssh-agent` entre múltiples sesiones de inicio de sesión

¿Hay alguna manera conveniente de garantizar que todos los inicios de sesión de un usuario determinado (es decir, yo) utilicen el mismo agente ssh? Pirateé un guión para que esto funcionara la mayor parte del tiempo, pero sospeché todo el tiempo que había alguna forma de hacerlo que me había perdido. Además, desde entonces ha habido avances sorprendentes en la tecnología informática, como por ejemplo este sitio web.

Entonces el objetivo aquí es que

• cada vez que inicio sesión en el cuadro, independientemente de si es a través de SSH, o en una sesión gráfica iniciada desde gdm / kdm / etc, o en una consola:
  • si mi nombre de usuario no se está ssh-agentejecutando actualmente , se inicia uno, se exportan las variables de entorno y se ssh-addllama.
  • de lo contrario, las coordenadas del agente existente se exportan en las variables de entorno de la sesión de inicio de sesión.

Esta facilidad es especialmente valiosa cuando la caja en cuestión se usa como un punto de relevo cuando se sshingresa en una tercera caja. En este caso, evita tener que escribir la frase de contraseña de la clave privada cada vez que ingresa y luego desea, por ejemplo, hacer git pusho algo.

El script que se proporciona a continuación hace esto de manera confiable, aunque falló recientemente cuando X se bloqueó y luego comencé otra sesión gráfica. Es posible que haya habido otros problemas en ese caso.

Aquí está mi guión de malo-es-bueno. Lo obtengo de mi .bashrc.

# ssh-agent-procure.bash
# v0.6.4
# ensures that all shells sourcing this file in profile/rc scripts use the same ssh-agent.
# copyright me, now; licensed under the DWTFYWT license.

mkdir -p "$HOME/etc/ssh";

function ssh-procure-launch-agent {
    eval `ssh-agent -s -a ~/etc/ssh/ssh-agent-socket`;
    ssh-add;
}

if [ ! $SSH_AGENT_PID ]; then
  if [ -e ~/etc/ssh/ssh-agent-socket ] ; then
    SSH_AGENT_PID=`ps -fC ssh-agent |grep 'etc/ssh/ssh-agent-socket' |sed -r 's/^\S+\s+(\S+).*$/\1/'`; 
    if [[ $SSH_AGENT_PID =~ [0-9]+ ]]; then
      # in this case the agent has already been launched and we are just attaching to it. 
      ##++  It should check that this pid is actually active & belongs to an ssh instance
      export SSH_AGENT_PID;
      SSH_AUTH_SOCK=~/etc/ssh/ssh-agent-socket; export SSH_AUTH_SOCK;
    else
      # in this case there is no agent running, so the socket file is left over from a graceless agent termination.
      rm ~/etc/ssh/ssh-agent-socket;
      ssh-procure-launch-agent;
    fi;
  else
    ssh-procure-launch-agent;
  fi;
fi;

Por favor, dime que hay una mejor manera de hacer esto. Además, por favor, no discutas las inconsistencias / fallas (por ejemplo, poner varcosas etc); Escribí esto hace un tiempo y desde entonces he aprendido muchas cosas.

También podría lanzar mi propia variación en la mezcla:

function sshagent_findsockets {
    find /tmp -uid $(id -u) -type s -name agent.\* 2>/dev/null
}

function sshagent_testsocket {
    if [ ! -x "$(which ssh-add)" ] ; then
        echo "ssh-add is not available; agent testing aborted"
        return 1
    fi

    if [ X"$1" != X ] ; then
        export SSH_AUTH_SOCK=$1
    fi

    if [ X"$SSH_AUTH_SOCK" = X ] ; then
        return 2
    fi

    if [ -S $SSH_AUTH_SOCK ] ; then
        ssh-add -l > /dev/null
        if [ $? = 2 ] ; then
            echo "Socket $SSH_AUTH_SOCK is dead!  Deleting!"
            rm -f $SSH_AUTH_SOCK
            return 4
        else
            echo "Found ssh-agent $SSH_AUTH_SOCK"
            return 0
        fi
    else
        echo "$SSH_AUTH_SOCK is not a socket!"
        return 3
    fi
}

function sshagent_init {
    # ssh agent sockets can be attached to a ssh daemon process or an
    # ssh-agent process.

    AGENTFOUND=0

    # Attempt to find and use the ssh-agent in the current environment
    if sshagent_testsocket ; then AGENTFOUND=1 ; fi

    # If there is no agent in the environment, search /tmp for
    # possible agents to reuse before starting a fresh ssh-agent
    # process.
    if [ $AGENTFOUND = 0 ] ; then
        for agentsocket in $(sshagent_findsockets) ; do
            if [ $AGENTFOUND != 0 ] ; then break ; fi
            if sshagent_testsocket $agentsocket ; then AGENTFOUND=1 ; fi
        done
    fi

    # If at this point we still haven't located an agent, it's time to
    # start a new one
    if [ $AGENTFOUND = 0 ] ; then
        eval `ssh-agent`
    fi

    # Clean up
    unset AGENTFOUND
    unset agentsocket

    # Finally, show what keys are currently in the agent
    ssh-add -l
}

alias sagent="sshagent_init"

Y luego, cada vez que inicio sesión, si quiero un agente adjunto (que no siempre), simplemente escribo sagent.

ssh -A [user@]remotehost

Creo que esto podría ser lo que estás buscando. Use el modificador -A cuando ejecute ssh reenvíe su agente ssh. Aquí hay un caso de uso:

Tengo un servidor remoto que tiene algunos repositorios git con un control remoto que apunta a github. Sin un ssh-agent ejecutándose en una sesión de pantalla, tengo que ingresar la frase de contraseña de mi clave para hacer un "maestro de origen de extracción de git". Booo! Además, debo tener mi clave privada instalada en el servidor remoto, ¡más Boooo!

En cambio, simplemente usando ssh -A [user@]remotehostpases a lo largo de mi agente ssh que se ejecuta localmente. Ahora, ya no necesito mi clave privada para existir en el host remoto. No creo que necesites hacer ningún script con ssh-agent.

Aquí hay uno bastante bueno que también funciona en Cygwin:

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 -efp ${SSH_AGENT_PID} | grep ssh-agent$ > /dev/null || {
         start_agent;
     }
else
     start_agent;
fi

Agréguelo a su .bash_profile o .bashrc

Fuente: http://www.cygwin.com/ml/cygwin/2001-06/msg00537.html

Intente usar llavero, está hecho para eso. http://www.gentoo.org/doc/en/keychain-guide.xml

Recientemente comencé a usar:

https://github.com/ccontavalli/ssh-ident

Todo lo que tengo que hacer es agregar:

  alias ssh=/path/to/ssh-ident

En mi archivo .bashrc. El guión se encarga de:

• crear un agente cuando se necesita por primera vez
• cargar las llaves necesarias bajo demanda
• compartir agentes en varias sesiones de inicio de sesión
• administro múltiples agentes, uno para cada 'identidad' que uso en línea, y use el agente correcto según el host al que me conecto o el directorio de trabajo actual.

Prefiero mantener las cosas lo más simple posible: (fragmento de ~/.profile)

check-ssh-agent() {
    [ -S "$SSH_AUTH_SOCK" ] && { ssh-add -l >& /dev/null || [ $? -ne 2 ]; }
}

# attempt to connect to a running agent
check-ssh-agent || export SSH_AUTH_SOCK="$(< ~/.tmp/ssh-agent.env)"
# if agent.env data is invalid, start a new one
check-ssh-agent || {
    eval "$(ssh-agent -s)" > /dev/null
    echo "$SSH_AUTH_SOCK" > ~/.tmp/ssh-agent.env
}

No pensé en usar -aantes, pero podría ser más fácil:

check-ssh-agent || export SSH_AUTH_SOCK=~/.tmp/ssh-agent.sock
check-ssh-agent || eval "$(ssh-agent -s -a ~/.tmp/ssh-agent.sock)" > /dev/null

En mi caso, he configurado posh-git en PowerShell y quería que cygwin usara el mismo agente ssh. Tuve que hacer algunas manipulaciones de ruta ya que usan diferentes carpetas tmp, y el archivo .env creado fue UTF16 con BOM y CR \ LF, por lo que fue divertido tratarlo. Agregar lo siguiente al .bashrc utilizado por cygwin debería funcionar:

# Connect to ssh-agent started by posh-git
SSH_AGENT_ENV=$(cygpath "$LOCALAPPDATA\Temp")
if [ -z $SSH_AUTH_SOCK ] && [ -z $SSH_TTY ]; then  # if no agent & not in ssh
  if [ -f "$SSH_AGENT_ENV/.ssh/SSH_AUTH_SOCK.env" ]; then
    AUTH_SOCK=$(iconv -c -f UTF-16LE -t US-ASCII "$SSH_AGENT_ENV/.ssh/SSH_AUTH_SOCK.env" | tr -d '\r\n')
    export SSH_AUTH_SOCK="${AUTH_SOCK/\/tmp/$SSH_AGENT_ENV}"
    ssh-add -l > /dev/null
    if [ $? = 2 ] ; then
      echo "Failed to setup posh-git ssh-agent using $AUTH_SOCK"
      unset SSH_AUTH_SOCK
    else
      echo "Found posh-git ssh-agent $AUTH_SOCK"
    fi
  else #Start new agent if you want (not shared by posh-git)
    echo "failed to setup posh-git ssh-agent"
    #eval `ssh-agent -s` > /dev/null
  fi
fi

De nuevo, un ejemplo para poner su .bash_profile inmediatamente y pedirle que agregue su clave predeterminada al iniciar sesión. El reenvío no era una opción en mi caso.

do-ssh-agent() {
  # function to start the ssh-agent and store the agent details for later logon
  ssh-agent -s > ~/.ssh-agent.conf 2> /dev/null
  . ~/.ssh-agent.conf > /dev/null
}

# set time a key should be kept in seconds
keyage=3600

if [ -f ~/.ssh-agent.conf ] ; then
  . ~/.ssh-agent.conf > /dev/null
  ssh-add -l > /dev/null 2>&1
  # $?=0 means the socket is there and it has a key
  # $?=1 means the socket is there but contains no key
  # $?=2 means the socket is not there or broken
  stat=$?
  if [ $stat -eq 1 ] ; then
    ssh-add -t $keyage > /dev/null 2>&1
  elif [ $stat -eq 2 ] ; then
    rm -f $SSH_AUTH_SOCK
    do-ssh-agent
    ssh-add -t $keyage > /dev/null 2>&1
  fi
else
  do-ssh-agent
  ssh-add -t $keyage > /dev/null 2>&1
fi

Esta es mi solución, adaptada de https://superuser.com/a/141233/5255 (en este hilo):

# attempt to connect to a running agent - cache SSH_AUTH_SOCK in ~/.ssh/
sagent()
{
    [ -S "$SSH_AUTH_SOCK" ] || export SSH_AUTH_SOCK="$(< ~/.ssh/ssh-agent.env)"

    # if cached agent socket is invalid, start a new one
    [ -S "$SSH_AUTH_SOCK" ] || {
        eval "$(ssh-agent)"
        ssh-add -t 25920000 -K ~/.ssh/id_rsa
        echo "$SSH_AUTH_SOCK" > ~/.ssh/ssh-agent.env
    }
}

crear archivo ~ / ssh-agent.sh

agent_out_file="$HOME/ssh-agent.out"

function initialize {
    pgrep ssh-agent && kill $(pgrep ssh-agent)
    ssh-agent -s > $agent_out_file 
    . $agent_out_file
}

pgrep ssh-agent
if [ $? -eq 0 ]; then # ssh agent running
    ssh-add -l > /dev/null 2>&1
    status=$?
    if [ $status -eq 0 ]; then # can connect to ssh agent and keys available
        echo nothing to do
    elif [ $status -eq 1 ]; then # can connect to ssh agent and no keys available
        echo nothing to do
    elif [ $status -eq 2 ]; then # cannot connect to ssh agent
        . $agent_out_file
    fi
else # ssh agent not running
    initialize   
fi

incluir el archivo en .bashrc

. ~/ssh-agent.sh

Esto es algo que he agregado que funciona para mí. Primero verifica si tiene un agente ejecutándose, en caso afirmativo, establecerá los entornos adecuados para él, si no, lo creará. También elimina la creación de agentes adicionales:

Solo ponlo en tu .bashrc

function start_agent() {
    killall ssh-agent  2> /dev/null
    ssh-agent | sed 's/ Agent pid//' > $SSH_ENV
    . $SSH_ENV > $SSH_PID_FILE
    ssh-add ~/.ssh/bb_readonly_rsa 2> /dev/null
}

mkdir -p "$HOME/.ssh/agent"
SSH_ENV="$HOME/.ssh/agent/env"
SSH_PID_FILE="$HOME/.ssh/agent/pid"

if [[ -e $SSH_PID_FILE ]]; then
    SSH_PID=$(< $SSH_PID_FILE) 
    PROCESS=$(ps -p $SSH_PID -o comm=)

    if [[ $PROCESS == 'ssh-agent' ]]; then
        . $SSH_ENV > $SSH_PID_FILE
    else 
        start_agent
    fi  
else
    start_agent
fi

También tengo una variación sobre este problema, tomada directamente de mi .bashrc:

# File for storing SSH agent information
OSH=".agent.${HOSTNAME}"

# Test if an agent file exists
if [ -f ${OSH} ];

    # We have one, so let's use it
    then eval `cat ${OSH}` >/dev/null

else

    # No file exists, so we must spawn a new agent
    eval `ssh-agent | tee ${OSH}` >/dev/null

fi

# Try to list agent keys
ssh-add -l &>/dev/null

# Determine the agent status
case $? in

    # Current and SSH keys installed, nothing to do here
    0) ;;

    # Current but no SSH keys installed, so we must add them
    1) ssh-add ;;

    # Stale, so we must redo from scratch with a new agent, then add keys
    *) eval `ssh-agent | tee ${OSH}` >/dev/null && ssh-add ;;

esac

Esta solución almacena una copia de la información del agente SSH en su directorio de inicio. En caso de que tenga un directorio de inicio montado en NFS que pueda compartirse entre varios hosts, el nombre de host se usa como parte del nombre de archivo para diferenciarlos, por lo que iniciar sesión desde una máquina no bloqueará el archivo del agente en uso en otra.

Comportamiento:

1) Las sesiones de usuario por primera vez se les solicita una frase de contraseña clave.

2) Las sesiones segunda, tercera y cuarta (etcétera) heredan el agente SSH y las claves agregadas en la primera.

3) Si el agente se mata o se bloquea, la primera sesión posterior creará un nuevo agente, sobrescribirá el archivo del agente con el nuevo y solicitará una frase clave nuevamente. Las sesiones creadas posteriormente se comportarán como el escenario 2), siempre y cuando el nuevo agente SSH siga ejecutándose.

(esto se refiere a la publicación 2 más alta, no pude agregar un comentario)

@raghavan: su ejemplo es útil, pero sugeriría cambiar las dos líneas que tienen

pgrep ssh-agent

a

pgrep -u $ USER ssh-agent> / dev / null

para que solo se encuentren los agentes que se ejecutan bajo el usuario actual, y el pid no se repite en la pantalla (limpiador).

También sugiero cambiar $ HOME / ssh-agent.out a $ HOME / .ssh-agent.out

Saludos

Leí su solución original y varias de las sugeridas, pero decidí simplificar el proceso para mi propio uso. Esto es lo que agregué en mi propio .bashrc:

    # get active ssh-agent, or launch new
    SSH_AGENT_PID=$(ps -fC ssh-agent | grep "ssh-agent -a ${HOME}/.ssh/ssh-agent-socket" | awk '{print $2}')
    if [ -z "${SSH_AGENT_PID}" ]; then
      # If there is no ssh-agent running, we'll make sure one hasn't left a socket file dangling
      rm ${HOME}/.ssh/ssh-agent-socket &> /dev/null
      # And of course start one
      eval $(ssh-agent -a ${HOME}/.ssh/ssh-agent-socket)
    else
      # We found a process matching our requirements, so sticking with that
      export SSH_AGENT_PID
      export SSH_AUTH_SOCK="${HOME}/.ssh/ssh-agent-socket"
    fi

He hecho un par de suposiciones aquí:

• Que el directorio ~ / .ssh existe.
• Que solo desea un socket ssh-agent por usuario en el sistema.
• Que la variable de entorno HOME está configurada (porque ¿por qué no lo haría, verdad?).
• Que manejará manualmente una situación en la que hay un proceso en ejecución, pero por alguna razón no usa el archivo de socket designado.

En general, creo que se siente como una solución simple.

Descubrí que a menudo tenía múltiples ssh-agentprocesos en ejecución, y que el PID dentro del nombre de archivo del socket nunca coincidía con el PID de una ejecución ssh-agent, por lo que pirateé algo para intentar recuperarme de estas condiciones, en base a numerosos ejemplos anteriores.

Es una función única, utiliza una variable Zsh para la ID de usuario si está allí, y trata de pasar menos tiempo analizando /tmpdirectorios posiblemente grandes restringiendo find(1)un poco más.

Probablemente todavía sea propenso a errores y sea complicado, pero algunas pruebas superficiales indican que funciona principalmente para mis casos de uso, así que aquí va:

attach_ssh_agent () {
  si [-n "$ SSH_AGENT_PID"]; entonces
    ssh-add -l> / dev / null
    ret = $?
    si [$ ret -ge 2]; entonces
      echo "El agente pid $ SSH_AGENT_PID es menos que útil (ret = $ ret) - matando ..."
      matar $ SSH_AGENT_PID
      desarmado $ SSH_AGENT_PID
    elif [$ ret = 1]; entonces
      echo "El agente pid $ SSH_AGENT_PID es menos que útil (ret = $ ret) - lo sembrará ..."
    más
      echo "Agente pid $ SSH_AGENT_PID"
      regreso
    fi
  fi
  si [-S "$ SSH_AUTH_SOCK"]; entonces
    ssh-add -l> / dev / null
    ret = $?
    si [$ ret = 2]; entonces
      echo "El socket $ SSH_AUTH_SOCK está muerto - eliminando ..."
      rm -f $ SSH_AUTH_SOCK
      desarmar SSH_AUTH_SOCK
    elif [$ ret = 1]; entonces
      echo "Socket $ SSH_AUTH_SOCK apunta a un agente sin claves ..."
      ssh-add
    más
      echo "Agente ssh encontrado $ SSH_AUTH_SOCK (ret = $ ret)"
      regreso
    fi
  fi
  para sf en $ (find / tmp / -mindepth 2 -maxdepth 2 -uid $ {UID: - $ (id -u)} -path '/tmp/ssh-*/agent.*' -type s); hacer
    prueba -r $ sf || Hacer continuación
    export SSH_AUTH_SOCK = $ sf
    SSH_AGENT_PID = $ (nombre base $ SSH_AUTH_SOCK | cut -d. -F2)
    # carreras con otras horquillas de proceso, argh
    prueba = 50
    mientras que [$ try -gt 0]; hacer
      try = $ (($ try-1))
      export SSH_AGENT_PID = $ (($ SSH_AGENT_PID + 1))
      echo "Prueba $ SSH_AUTH_SOCK -> $ SSH_AGENT_PID"
      ssh_agent_running = $ (ps -u $ USER | grep ssh-agent)
      if [-z "$ ssh_agent_running"]; entonces
        echo "Socket $ SSH_AUTH_SOCK no contiene un enlace a ningún agente en ejecución, eliminando ..."
        rm -f $ SSH_AUTH_SOCK
        Hacer continuación
      fi
      si echo "$ ssh_agent_running" | \
           awk '$ 1 ==' $ SSH_AGENT_PID '{
                  encontrado = 1;
                  salida (0);
              }
              FIN {
                  si se encuentra) {
                      print "no se encontró el PID en ejecución '$ SSH_AGENT_PID'";
                      salida (1);
                  }
              } '; entonces
        ssh-add -l> / dev / null
        ret = $?
        si [$ ret -ge 2]; entonces
          echo "El socket $ SSH_AUTH_SOCK no contiene un enlace a un agente útil en $ SSH_AGENT_PID - eliminando ..."
          rm -f $ SSH_AUTH_SOCK
          matar $ SSH_AGENT_PID
          desarmar SSH_AGENT_PID
          continuar 2
        elif [$ ret = 1]; entonces
          echo "El socket $ SSH_AUTH_SOCK contiene un enlace a un agente poco útil en $ SSH_AGENT_PID - seeding ..."
          ssh-add
          Si ! ssh-add -l> / dev / null; entonces
            echo "El socket $ SSH_AUTH_SOCK todavía contiene un enlace a un agente poco útil en $ SSH_AGENT_PID - abortando".
            regreso
          más
            rotura
          fi
        más
          rotura
        fi
      más
# echo "No se pudo hacer coincidir el socket $ SSH_AUTH_SOCK con el agente PID $ SSH_AGENT_PID - omitiendo ..."
        Hacer continuación
      fi
    hecho
    si [$ try -gt 0]; entonces
      echo "Agente ssh encontrado $ SSH_AUTH_SOCK"
      echo "Agente pid $ SSH_AGENT_PID"
      regreso
    fi
  hecho
  if [-n "$ try" -a -n "$ SSH_AUTH_SOCK" -a -n "$ ssh_agent_running"]; entonces
    echo "Lo intentamos muchas veces, pero no pudimos igualar $ SSH_AUTH_SOCK con ninguno de los agentes en ejecución, suspiro"
    echo "$ ssh_agent_running"
    echo "Dejando estas sobras y comenzando un nuevo agente ..."
  fi
  eval $ (ssh-agent -t 28800)
  ssh-add
}

Aquí está mi giro en esto. ' Fuente ' el siguiente script de mi .bash_profile :

MYAGENTS=(`pgrep -U $USER -f ^ssh-agent$|sort -n`)

echo "Found ${#MYAGENTS[@]} ssh-agents."

# Let's try to take over the agents, like we do everynight Pinky!
if [[ "${MYAGENTS[@]}" ]];then
  KEEPER=${MYAGENTS[0]}
  echo KEEPER: $KEEPER
  OUTCAST=${MYAGENTS[@]:1}
  [[ "$OUTCAST" ]] && { echo "Goodbye agent $OUTCAST"; kill $OUTCAST; }
  SSH_AUTH_SOCK=`awk '/tmp\/ssh/ {print $NF}' /proc/$KEEPER/net/unix`
  export SSH_AUTH_SOCK;
  SSH_AGENT_PID=$KEEPER; export SSH_AGENT_PID;
else
  NEWAGENT="`ssh-agent`"
  echo $NEWAGENT;
  eval $NEWAGENT
fi

ssh-add -l | grep "The agent has no identities" && ssh-add

Aquí hay un script simple que siempre reutilizará el mismo ssh-agent, o iniciará ssh-agent si no se está ejecutando. La clave es usar la -aopción para usar el mismo nombre de socket. De lo contrario, de forma predeterminada, elegirá un nombre de socket aleatorio cada vez. También puede combinar fácilmente estas 3 líneas en un alias de 1 línea.

# set SSH_AUTH_SOCK env var to a fixed value
export SSH_AUTH_SOCK=~/.ssh/ssh-agent.sock

# test whether $SSH_AUTH_SOCK is valid
ssh-add -l 2>/dev/null >/dev/null

# if not valid, then start ssh-agent using $SSH_AUTH_SOCK
[ $? -ge 2 ] && ssh-agent -a "$SSH_AUTH_SOCK" >/dev/null

fuente