Teilen des gleichen "ssh-agent" bei mehreren Anmeldesitzungen

Gibt es eine bequeme Möglichkeit, um sicherzustellen, dass alle Anmeldungen eines bestimmten Benutzers (dh ich) denselben ssh-Agenten verwenden? Ich habe ein Skript gehackt, damit dies die meiste Zeit funktioniert, aber ich habe die ganze Zeit vermutet, dass es einen Weg gibt, den ich gerade verpasst habe. Darüber hinaus gab es seitdem erstaunliche Fortschritte in der Computertechnologie, wie zum Beispiel diese Website.

Das Ziel hier ist also das

• Jedes Mal, wenn ich mich in der Box anmelde, egal ob über SSH oder in einer grafischen Sitzung, die von gdm / kdm / etc aus gestartet wurde, oder an einer Konsole:
  • Wenn für meinen Benutzernamen derzeit kein Programm ssh-agentausgeführt wird, wird eines gestartet, die Umgebungsvariablen werden exportiert und ssh-addaufgerufen.
  • Andernfalls werden die Koordinaten des vorhandenen Agenten in die Umgebungsvariablen der Anmeldesitzung exportiert.

Diese Funktion ist besonders dann nützlich, wenn die betreffende Box als sshRelaispunkt beim Einstecken in eine dritte Box verwendet wird. In diesem Fall müssen Sie die Passphrase des privaten Schlüssels nicht jedes Mal eingeben, wenn Sie sshen, und möchten dann beispielsweise git pushetwas tun oder so.

Das unten angegebene Skript erledigt dies größtenteils zuverlässig, obwohl es kürzlich verpfuscht wurde, als X abstürzte und ich dann eine weitere grafische Sitzung startete. In diesem Fall könnte eine andere Verrücktheit vor sich gegangen sein.

Hier ist mein schlechtes Skript. Ich beziehe das von meinem .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;

Sagen Sie mir bitte, dass es einen besseren Weg gibt, dies zu tun. Bitte wählen Sie auch nicht die Inkonsistenzen / Gaffes aus (zB das Einfügen von varSachen etc); Ich habe das vor einiger Zeit geschrieben und seitdem viel gelernt.

Ich könnte genauso gut meine eigene Variation in den Mix werfen:

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"

Und jedes Mal, wenn ich mich anmelde, tippe ich einfach ein , wenn ich möchte, dass ein Agent angehängt wird (was nicht immer der Fall ist ) sagent.

ssh -A [user@]remotehost

Ich denke, das könnte das sein, wonach Sie suchen. Verwenden Sie die Option -A, wenn Sie ssh ausführen und Ihren ssh-agent weiterleiten. Hier ist ein Anwendungsfall:

Ich habe einen Remote-Server, auf dem sich einige Git-Repos befinden, und ein Remote-Server zeigt auf Github. Ohne einen SSH-Agenten, der in einer Bildschirmsitzung ausgeführt wird, muss ich die Passphrase für meinen Schlüssel eingeben, um einen "Git-Pull-Origin-Master" zu erstellen. Booo! Außerdem muss mein privater Schlüssel auf dem Remote-Server installiert sein - mehr Boooo!

Stattdessen benutze ssh -A [user@]remotehostich einfach Pässe entlang meines lokal laufenden ssh-Agenten. Jetzt brauche ich meinen privaten Schlüssel nicht mehr, um überhaupt auf dem Remote-Host zu existieren. Ich glaube nicht, dass Sie mit ssh-agent überhaupt Skripte erstellen müssen.

Hier ist eine ziemlich nette, die auch in Cygwin funktioniert:

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

Fügen Sie es Ihrem .bash_profile oder .bashrc hinzu

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

Versuchen Sie es mit Schlüsselbund, es ist dafür gemacht. http://www.gentoo.org/doc/en/keychain-guide.xml

Ich habe vor kurzem begonnen mit:

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

Alles was ich tun muss, ist hinzuzufügen:

  alias ssh=/path/to/ssh-ident

In meiner .bashrc-Datei. Das Skript kümmert sich um:

• Erstellen eines Agenten, wenn er zum ersten Mal benötigt wird
• Laden Sie die erforderlichen Schlüssel auf Anfrage
• Agenten für mehrere Anmeldesitzungen freigeben
• Verwalten Sie mehrere Agenten, einen für jede 'Identität', die ich online verwende, und verwenden Sie den richtigen Agenten basierend auf dem Host, mit dem ich mich verbinde, oder dem aktuellen Arbeitsverzeichnis.

Ich ziehe es vor, die Dinge so einfach wie möglich zu halten: (Ausschnitt aus ~/.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
}

Ich habe vorher nicht daran gedacht, es zu benutzen -a, aber es könnte einfacher sein:

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

In meinem Fall habe ich Posh-Git in PowerShell eingerichtet und wollte, dass Cygwin denselben ssh-Agenten verwendet. Ich musste einige Pfadmanipulationen durchführen, da sie unterschiedliche tmp-Ordner verwendeten und die erstellte .env-Datei UTF16 mit BOM und CR \ LF war, so dass es Spaß machte, damit umzugehen. Das Hinzufügen des Folgenden zu der von Cygwin verwendeten .bashrc sollte funktionieren:

# 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

Nochmals ein Beispiel, um Ihr .bash_profile sofort einzutragen und Ihren Standardschlüssel bei der Anmeldung hinzuzufügen. Die Weiterleitung war in meinem Fall keine Option.

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

Dies ist meine Lösung, angepasst von https://superuser.com/a/141233/5255 (in diesem Thread):

# 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
    }
}

Erstelle die Datei ~ / 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

Fügen Sie die Datei in .bashrc ein

. ~/ssh-agent.sh

Dies ist etwas, das ich hinzugefügt habe und das für mich funktioniert. Zuerst wird geprüft, ob ein Agent ausgeführt wird. Wenn ja, werden die entsprechenden Umgebungen festgelegt, wenn nicht, wird er erstellt. Außerdem wird das Erstellen zusätzlicher Agenten vermieden:

Legen Sie es einfach in Ihren .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

Ich habe auch eine Variation dieses Problems, die direkt aus meiner .bashrc-Datei stammt:

# 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

Diese Lösung speichert eine Kopie der SSH-Agenteninformationen in Ihrem Ausgangsverzeichnis. Wenn Sie über ein NFS-automounted-Ausgangsverzeichnis verfügen, das möglicherweise von mehreren Hosts gemeinsam genutzt wird, wird der Hostname als Teil des Dateinamens verwendet, um zwischen diesen zu unterscheiden. Wenn Sie sich also von einem Computer aus anmelden, wird die auf einem anderen verwendete Agentendatei nicht überlastet.

Verhalten:

1) Erstbenutzersitzungen werden zur Eingabe einer Passphrase aufgefordert.

2) Die zweite, dritte und vierte Sitzung (usw.) erben den SSH-Agenten und die Schlüssel, die in der ersten hinzugefügt wurden.

3) Wenn der Agent getötet wird oder abstürzt, erstellt die erste nachfolgende Sitzung einen neuen Agenten, überschreibt die Agentendatei mit der neuen und fordert Sie zur erneuten Eingabe einer Passphrase auf. Nachfolgend erstellte Sitzungen verhalten sich wie Szenario 2), solange der neue SSH-Agent ausgeführt wird.

(Dies bezieht sich auf den Beitrag 2 höher, ich konnte keinen Kommentar hinzufügen)

@raghavan: Ihr Beispiel ist nützlich, aber es empfiehlt sich, die beiden vorhandenen Zeilen zu ändern

pgrep ssh-agent

zu

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

Damit werden nur Agenten gefunden, die unter dem aktuellen Benutzer ausgeführt werden, und die PID wird nicht auf dem Bildschirm wiedergegeben (Bereinigung).

Empfiehlt sich auch, $ HOME / ssh-agent.out in $ HOME / .ssh-agent.out zu ändern

Grüße

Ich habe Ihre ursprüngliche Lösung und eine Reihe der vorgeschlagenen Lösungen gelesen, mich jedoch entschlossen, den Prozess für meinen eigenen Gebrauch zu vereinfachen. Das habe ich in meiner eigenen .bashrc hinzugefügt:

    # 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

Ich habe hier ein paar Annahmen getroffen:

• Dass das ~ / .ssh-Verzeichnis existiert.
• Sie möchten nur einen ssh-agent-Socket pro Benutzer im System.
• Dass die Umgebungsvariable HOME gesetzt ist (weil warum nicht?).
• Dass Sie eine Situation, in der ein Prozess ausgeführt wird, manuell behandeln, aber aus irgendeinem Grund die angegebene Socket-Datei nicht verwenden.

Alles in allem fühlt es sich nach einer einfachen Lösung an.

Ich stellte fest, dass häufig mehrere ssh-agentProzesse ausgeführt wurden und dass die PID im Socket-Dateinamen nie mit der PID einer Ausführung übereinstimmte. Daher ssh-agenthabe ich anhand zahlreicher Beispiele oben versucht, mich von diesen Bedingungen zu erholen.

Es handelt sich um eine einzelne Funktion, die eine Zsh-Variable für die Benutzer-ID verwendet, wenn diese vorhanden ist, und versucht, weniger Zeit mit dem Parsen möglicherweise großer /tmpVerzeichnisse zu verbringen, indem sie find(1)etwas mehr einschränkt .

Es ist wahrscheinlich immer noch fehleranfällig und verworren, aber einige flüchtige Tests zeigen, dass es hauptsächlich für meine Anwendungsfälle funktioniert.

attach_ssh_agent () {
  if [-n "$ SSH_AGENT_PID"]; dann
    ssh-add -l> / dev / null
    ret = $?
    if [$ ret -ge 2]; dann
      echo "Agent pid $ SSH_AGENT_PID ist weniger als nützlich (ret = $ ret) - töte ..."
      töte $ SSH_AGENT_PID
      Deaktivieren Sie $ SSH_AGENT_PID
    elif [$ ret = 1]; dann
      echo "Agent pid $ SSH_AGENT_PID ist weniger als nützlich (ret = $ ret) - wird es aussäen ..."
    sonst
      echo "Agent pid $ SSH_AGENT_PID"
      Rückkehr
    fi
  fi
  if [-S "$ SSH_AUTH_SOCK"]; dann
    ssh-add -l> / dev / null
    ret = $?
    if [$ ret = 2]; dann
      echo "Socket $ SSH_AUTH_SOCK ist tot - Löschen ..."
      rm -f $ SSH_AUTH_SOCK
      deaktivieren Sie SSH_AUTH_SOCK
    elif [$ ret = 1]; dann
      echo "Socket $ SSH_AUTH_SOCK zeigt auf einen Agenten ohne Schlüssel ..."
      ssh-add
    sonst
      echo "ssh-agent $ SSH_AUTH_SOCK gefunden (ret = $ ret)"
      Rückkehr
    fi
  fi
  für sf in $ (find / tmp / -mindepth 2 -maxdepth 2 -uid $ {UID: - $ (id -u)} -path '/tmp/ssh-*/agent.*' -Typ s); machen
    test -r $ sf || fortsetzen
    exportiere SSH_AUTH_SOCK = $ sf
    SSH_AGENT_PID = $ (Basisname $ SSH_AUTH_SOCK | cut -d. -F2)
    # Rennen mit anderen Prozessgabeln, argh
    try = 50
    while [$ try -gt 0]; machen
      try = $ (($ try-1))
      exportiere SSH_AGENT_PID = $ (($ SSH_AGENT_PID + 1))
      echo "Testen von $ SSH_AUTH_SOCK -> $ SSH_AGENT_PID"
      ssh_agent_running = $ (ps -u $ USER | grep ssh-agent)
      if [-z "$ ssh_agent_running"]; dann
        echo "Socket $ SSH_AUTH_SOCK enthält keinen Link zu einem laufenden Agenten - Löschen ..."
        rm -f $ SSH_AUTH_SOCK
        fortsetzen
      fi
      if echo "$ ssh_agent_running" | \
           awk '$ 1 ==' $ SSH_AGENT_PID '{
                  gefunden = 1;
                  Ausfahrt (0);
              }
              ENDE {
                  wenn gefunden) {
                      print "Laufende PID '$ SSH_AGENT_PID' nicht gefunden";
                      Ausfahrt (1);
                  }
              } '; dann
        ssh-add -l> / dev / null
        ret = $?
        if [$ ret -ge 2]; dann
          echo "Socket $ SSH_AUTH_SOCK enthält keinen Link zu einem nützlichen Agenten unter $ SSH_AGENT_PID - Löschen ..."
          rm -f $ SSH_AUTH_SOCK
          töte $ SSH_AGENT_PID
          Deaktivieren Sie SSH_AGENT_PID
          weiter 2
        elif [$ ret = 1]; dann
          echo "Socket $ SSH_AUTH_SOCK enthält einen Link zu einem weniger nützlichen Agenten unter $ SSH_AGENT_PID - Seeding ..."
          ssh-add
          wenn ! ssh-add -l> / dev / null; dann
            echo "Socket $ SSH_AUTH_SOCK enthält immer noch einen Link zu einem weniger nützlichen Agenten bei $ SSH_AGENT_PID - Abbruch."
            Rückkehr
          sonst
            brechen
          fi
        sonst
          brechen
        fi
      sonst
# echo "Socket $ SSH_AUTH_SOCK konnte nicht mit Agent-PID $ SSH_AGENT_PID abgeglichen werden - Überspringen ..."
        fortsetzen
      fi
    getan
    if [$ try -gt 0]; dann
      echo "ssh-agent $ SSH_AUTH_SOCK gefunden"
      echo "Agent pid $ SSH_AGENT_PID"
      Rückkehr
    fi
  getan
  if [-n "$ try" -a -n "$ SSH_AUTH_SOCK" -a -n "$ ssh_agent_running"]; dann
    echo "Wir haben es viele Male versucht, konnten aber $ SSH_AUTH_SOCK keinem der laufenden Agenten zuordnen, seufz"
    echo "$ ssh_agent_running"
    echo "Diese Reste zurücklassen und einen neuen Agenten gründen ..."
  fi
  eval $ (ssh-agent -t 28800)
  ssh-add
}

Hier ist meine Meinung dazu. I ‚ Quelle ‘ die folgenden Skript aus meinem 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

Hier ist ein einfaches Skript, das immer denselben ssh-agent wiederverwendet oder ssh-agent startet, wenn er nicht ausgeführt wird. Der Schlüssel ist, die -aOption zu verwenden, um denselben Socket-Namen zu verwenden. Andernfalls wird standardmäßig jedes Mal ein zufälliger Socket-Name ausgewählt. Sie können diese 3 Zeilen auch problemlos zu einem 1-Zeilen-Alias ​​kombinieren.

# 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

Quelle