Aynı `ssh-agent`'ı çoklu oturum açma oturumları arasında paylaşma

Belirli bir kullanıcıdan (yani ben) gelen tüm girişlerin aynı ssh-agent'ı kullanmasını sağlamanın uygun bir yolu var mı? Çoğu zaman bu işi yapmak için bir senaryoyu hackledim, ama başından beri ıskalamamın bir yolu olduğundan şüphelendim. Ek olarak, o zamandan beri, örneğin bu web sitesi gibi, bilgisayar teknolojisinde inanılmaz gelişmeler oldu.

Yani burada amaç bu

• ne zaman ister SSH üzerinden, ister gdm / kdm / etc'den başlayan bir grafik oturumda veya bir konsolda kutuya giriş yaptığımda:
  • eğer kullanıcı adım şu anda ssh-agentçalışıyorsa, biri başlatılır, ortam değişkenleri dışa aktarılır ve ssh-addçağrılır.
  • Aksi halde, mevcut aracının koordinatları giriş oturumunun ortam değişkenlerinde dışa aktarılır.

Bu tesis, söz konusu kutunun sshüçüncü bir kutuya girerken geçiş noktası olarak kullanılması durumunda özellikle değerlidir . Bu durumda, her girişte özel anahtarın parolasını girmek zorunda kalmaz ve daha sonra, örneğin yapmak git pushveya bir şey yapmaktan kaçınır .

Aşağıda verilen senaryo bunu en güvenilir şekilde yapar, ancak X düştüğünde ve daha sonra başka bir grafik oturumu başlattığımda son zamanlarda ortaya çıktı. Bu durumda başka bir karmaşa yaşanmış olabilir.

İşte benim kötü-iyi-senaryom. Bunu benden kaynaklarım .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;

Lütfen bunu yapmanın daha iyi bir yolu olduğunu söyle. Ayrıca tutarsızlıklar / gaffes nitpick etmeyiniz (örneğin koyarak varbir şeyler etc); Bunu bir süre önce yazdım ve o zamandan beri birçok şey öğrendim.

Kendi varyasyonumu da karışıma ekleyebilirim:

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"

Ben Ve eğer her seferinde, giriş istediğiniz (Hep yok), sadece yazın tutunmuş bir maddenin sagent.

ssh -A [user@]remotehost

Sanırım aradığın şey bu olabilir. Ssh-agent'ınızı ssh ile oynatırken -A düğmesini kullanın. İşte bir usecase:

Üzerinde bazı Git repoları olan bir uzak sunucum var ve üzerinde github olan bir uzaktan kumanda var. Bir ekran oturumunda çalışan bir ssh-ajanı olmadan, bir "git pull origin ana yöneticisi" yapmak için anahtarımın şifresini girmem gerekiyor. Booo! Ayrıca, özel sunucuya uzak sunucuya yüklenmiş olmalı - daha fazla Boooo!

Bunun yerine, sadece ssh -A [user@]remotehostyerel olarak çalışan ssh-agent'ım boyunca geçişler kullanmak . Artık, uzak ana bilgisayarda bile bulunabilmek için özel anahtarıma ihtiyacım yok. Herhangi bir komut dosyası ssh-agent ile yapmanız gerektiğine inanmıyorum.

İşte Cygwin'de de çalışan çok güzel bir tane:

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

.Bash_profile veya .bashrc dosyasına ekleyin

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

Bunun için yapılmış anahtarlık kullanmayı deneyin. http://www.gentoo.org/doc/en/keychain-guide.xml

Yakın zamanda kullanmaya başladım:

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

Tek yapmam gereken eklemek:

  alias ssh=/path/to/ssh-ident

.Bashrc dosyamda. Senaryo şunlarla ilgileniyor:

• İlk ihtiyaç duyulduğunda bir aracı oluşturmak
• talep üzerine gerekli anahtarları yükleyin
• ajanları çoklu giriş oturumlarında paylaş
• çevrimiçi kullandığım her 'kimlik' için bir tane olan birden fazla aracı yönetin ve bağlı olduğum ana bilgisayara veya geçerli çalışma dizinine göre doğru aracı kullanın.

İşleri olabildiğince basit tutmayı tercih ederim: (snippet from ~/.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
}

Daha -aönce kullanmayı düşünmedim , ancak daha kolay olabilir:

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

Benim durumumda PowerShell'de posh-git kurulumum var ve cygwin'in aynı ssh-agent'ı kullanmasını istedim. Farklı tmp klasörleri kullandıkları için bazı yol manipülasyonları yapmak zorunda kaldım ve oluşturulan .env dosyası BOM ve CR \ LF ile UTF16 idi, bu yüzden başa çıkmak eğlenceli oldu. Cygwin tarafından kullanılan .bashrc dosyasına aşağıdakilerin eklenmesi gerekir:

# 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

Yine bir .bash_profile dosyasını hemen koymak ve oturum açma sırasında varsayılan anahtarınızı eklemek isteyen bir örnek. Benim durumumda yönlendirme bir seçenek değildi.

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

Bu benim çözümüm, https://superuser.com/a/141233/5255 (bu konuda)

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

dosya oluştur ~ / 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

dosyayı .bashrc dosyasına dahil et

. ~/ssh-agent.sh

Bu benim için işe yarayan bir şey ekledi. İlk önce çalışan bir aracınız olup olmadığını kontrol eder, eğer evet ise uygun ortamları belirler, eğer yaratmazsa. Ayrıca ekstra ajan oluşturmayı da ortadan kaldırır:

Sadece içine koy .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

Bu problemde de doğrudan benim .bashrc'den alınmış bir çeşitlilik var:

# 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

Bu çözüm, SSH aracısı bilgilerinin bir kopyasını giriş dizininizde saklar. Birden fazla ana bilgisayar arasında paylaşılabilecek bir NFS otomasyonlu ana dizininiz varsa, ana makine adı, aralarında ayrım yapmak için dosya adının bir parçası olarak kullanılır; bu nedenle, bir makineden oturum açmak, diğer bir bilgisayarda kullanılan aracı dosyasını engellemez.

Davranış:

1) İlk kez kullanıcı oturumlarından bir anahtar parolası girmeniz istenir.

2) İkinci, üçüncü ve dördüncü (etetet) oturumları SSH ajanını ve ilkinde eklenen anahtarları miras alır.

3) Eğer ajan öldürülürse veya çökerse, sonraki ilk oturum yeni bir ajan yaratacaktır, ajan dosyasının üzerine yenisini yazınız - ve tekrar bir anahtar şifresi isteyiniz. Daha sonra oluşturulan oturumlar, yeni SSH ajanı çalışmaya devam ettiği sürece, senaryo 2) gibi davranacaktır.

(Bu, 2 gönderisinin daha yüksek olduğunu gösterir, yorum ekleyemedim)

@ ragvan: Örneğiniz kullanışlıdır, ancak iki satırın değiştirilmesini önerir.

pgrep ssh aracısı

için

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

Böylece yalnızca geçerli kullanıcının altında çalışan aracılar bulunur ve bu ücret ekrana yansıtılmaz (temizleyici).

$ HOME / ssh-agent.out dosyasını $ HOME / .ssh-agent.out olarak değiştirmeyi de önerebilir

Saygılarımızla

Orijinal çözümünüzü ve bir dizi önerilen çözümü okudum, ancak işlemi kendi kullanımım için basitleştirmeye karar verdim. Kendi kendime .bashrc de eklediğim şey:

    # 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

Burada birkaç varsayımda bulundum:

• ~ / .Ssh dizininin var olduğunu.
• Sistemde kullanıcı başına sadece bir ssh-agent soketi istediğinizi.
• HOME ortam değişkeninin ayarlandığı (çünkü neden olmasın değil mi?).
• Çalışan bir işlemin olduğu bir durumu elle idare edersiniz, ancak bir nedenden dolayı belirtilen soket dosyasını kullanmaz.

Sonuçta bence basit bir çözüm gibi geliyor.

Sık sık ssh-agentçalışan birden çok işlemim olduğunu ve soket dosya adının içindeki PID'nin aslında çalışanların PID'iyle hiçbir zaman eşleşmediğini ssh-agentbuldum, bu nedenle yukarıdaki koşullara dayanarak, bu koşullardan kurtulmaya çalışmak için bir şey hackledim.

Tek bir işlevdir, eğer varsa kullanıcı kimliği için bir Zsh değişkeni kullanır ve biraz daha fazla /tmpkısıtlayarak büyük dizinleri ayrıştırmak için daha az zaman harcar find(1).

Muhtemelen hala hataya açık ve sarsılmış bir durumdur, ancak bazı el yazısı testleri çoğunlukla benim kullanım durumlarım için işe yaradığını gösteriyor.

attach_ssh_agent () {
  eğer [-n "$ SSH_AGENT_PID"]; sonra
    ssh-add -l> / dev / null
    ret = $?
    eğer [$ ret -ge 2]; sonra
      echo "Ajan pid $ SSH_AGENT_PID faydadan daha az (ret = $ ret) - öldürüyor ..."
      $ SSH_AGENT_PID öldür
      $ SSH_AGENT_PID ayarını kaldır
    elif [$ ret = 1]; sonra
      echo "Ajan pid $ SSH_AGENT_PID faydadan daha az (ret = $ ret) - onu tohumlayacak ..."
    Başka
      yankı "Ajan pid $ SSH_AGENT_PID"
      dönüş
    fi
  fi
  eğer [-S "$ SSH_AUTH_SOCK"]; sonra
    ssh-add -l> / dev / null
    ret = $?
    eğer [$ ret = 2]; sonra
      echo "Soket $ SSH_AUTH_SOCK öldü - siliniyor ..."
      rm -f $ SSH_AUTH_SOCK
      SSH_AUTH_SOCK'ı aç
    elif [$ ret = 1]; sonra
      echo "Soket $ SSH_AUTH_SOCK anahtarsız bir ajanı işaret ediyor ..."
      ssh-add
    Başka
      echo "ssh aracısı $ SSH_AUTH_SOCK bulundu (ret = $ ret)"
      dönüş
    fi
  fi
  sf için $ (find / tmp / -mindepth 2 -maxdepth 2 -uid $ {UID: - $ (id -u)} -path '/tmp/ssh-*/agent.*' -type s); yap
    test -r $ sf || devam et
    dışa aktar SSH_AUTH_SOCK = $ sf
    SSH_AGENT_PID = $ (taban adı $ SSH_AUTH_SOCK | cut -d. -F2)
    # diğer işlem çatallarla yarış, argh
    deneyin = 50
    [$ try -gt 0] iken; yap
      denemek = $ (($ denemek-1))
      dışa aktarma SSH_AGENT_PID = $ (($ SSH_AGENT_PID + 1))
      echo "$ SSH_AUTH_SOCK -> $ SSH_AGENT_PID Test Ediliyor"
      ssh_agent_running = $ (ps -u $ USER | grep ssh-agent)
      eğer [-z "$ ssh_agent_running"]; sonra
        echo "$ SSH_AUTH_SOCK Soket, çalışan herhangi bir araca bağlantı içermiyor - siliniyor ..."
        rm -f $ SSH_AUTH_SOCK
        devam et
      fi
      eğer echo "$ ssh_agent_running" | \
           awk '$ 1 ==' $ SSH_AGENT_PID '{
                  = 1 Bulunan;
                  çıkış (0);
              }
              SON {
                  Eğer bulunursa) {
                      "PID '$ SSH_AGENT_PID' çalışan PID'yi bulamadı";
                      çıkış (1);
                  }
              } '; sonra
        ssh-add -l> / dev / null
        ret = $?
        eğer [$ ret -ge 2]; sonra
          echo "$ SSH_AUTH_SOCK Soketi, $ SSH_AGENT_PID - yararlı bir ajana bağlantı içermiyor - siliniyor ..."
          rm -f $ SSH_AUTH_SOCK
          $ SSH_AGENT_PID öldür
          SSH_AGENT_PID ayarını kaldır
          2 devam
        elif [$ ret = 1]; sonra
          echo "$ SSH_AUTH_SOCK soketi, $ SSH_AGENT_PID - ekim ... 'de yararlı bir ajandan daha düşük bir bağlantı içeriyor
          ssh-add
          Eğer ! ssh-add -l> / dev / null; sonra
            echo "$ SSH_AUTH_SOCK soketi hala $ SSH_AGENT_PID - iptali için yararlı bir ajandan daha düşük bir bağlantı içeriyor."
            dönüş
          Başka
            mola
          fi
        Başka
          mola
        fi
      Başka
# echo "$ SSH_AUTH_SOCK soketiyle PID $ SSH_AGENT_PID soketiyle eşleştirilemedi - atlama ..."
        devam et
      fi
    tamam
    eğer [$ try -gt 0]; sonra
      yankı "ssh-agent $ SSH_AUTH_SOCK bulundu"
      yankı "Ajan pid $ SSH_AGENT_PID"
      dönüş
    fi
  tamam
  eğer [-n "$ deneyin" -a -n "$ SSH_AUTH_SOCK" -a -n "$ ssh_agent_running"]; sonra
    echo "Birçok kez denedik, ancak $ SSH_AUTH_SOCK çalışan tüm ajanlarla eşleşemedi"
    echo "$ ssh_agent_running"
    echo "Bu artıkları geride bırakmak ve yeni bir ajan açmak ..."
  fi
  eval $ (ssh-ajan -t 28800)
  ssh-add
}

İşte bu konuda benim dönüş. Ben ' kaynak ' aşağıda senaryo benim dan .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

İşte her zaman aynı ssh-agent'ı tekrar kullanacak ya da çalışmıyorsa ssh-agent'ı başlatacak basit bir script. Anahtar, -aaynı soket adını kullanma seçeneğini kullanmaktır. Aksi takdirde, varsayılan olarak her seferinde rastgele bir soket adı seçer. Bu 3 satırı da 1 satır diğer adıyla kolayca birleştirebilirsiniz.

# 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

kaynak