Berbagi `ssh-agent` yang sama di antara beberapa sesi login

Apakah ada cara mudah untuk memastikan bahwa semua login dari pengguna yang diberikan (yaitu saya) menggunakan ssh-agent yang sama? Saya meretas naskah untuk membuat pekerjaan ini sebagian besar waktu, tapi saya curiga selama ini ada beberapa cara untuk melakukannya yang baru saja saya lewatkan. Selain itu, sejak saat itu telah ada kemajuan luar biasa dalam teknologi komputasi, seperti misalnya situs web ini.

Jadi tujuannya di sini adalah itu

• setiap kali saya masuk ke kotak, terlepas dari apakah itu melalui SSH, atau dalam sesi grafis dimulai dari gdm / kdm / etc, atau di konsol:
  • jika nama pengguna saya saat ini tidak ssh-agentberjalan, satu dimulai, variabel lingkungan diekspor, dan ssh-adddipanggil.
  • jika tidak, koordinat agen yang ada diekspor dalam variabel lingkungan sesi login.

Fasilitas ini sangat berharga ketika kotak tersebut digunakan sebagai titik relai ketika sshmasuk ke kotak ketiga. Dalam hal ini ia menghindari keharusan mengetikkan frasa sandi kunci pribadi setiap kali Anda melakukan ssh dan kemudian ingin, misalnya, melakukan git pushatau sesuatu.

Script yang diberikan di bawah ini melakukan hal ini sebagian besar andal, meskipun gagal baru-baru ini ketika X crash dan saya kemudian memulai sesi grafis lainnya. Mungkin ada kelicikan lain yang terjadi dalam contoh itu.

Ini skrip buruk-baik-saya. Saya sumber ini dari .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;

Tolong beritahu saya ada cara yang lebih baik untuk melakukan ini. Juga tolong jangan lihat ketidakkonsistenan / kesalahan (mis. Memasukkan varbarang ke dalam etc); Saya menulis ini beberapa waktu lalu dan sejak itu belajar banyak hal.

Saya mungkin juga memasukkan variasi saya sendiri ke dalam campuran:

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"

Dan kemudian setiap kali saya masuk, jika saya ingin agen terlampir (yang saya tidak selalu), saya ketik saja sagent.

ssh -A [user@]remotehost

Saya pikir ini mungkin yang Anda cari. Gunakan sakelar -A saat menjalankan ssh forward ssh-agent Anda. Berikut ini usecase:

Saya memiliki server jarak jauh yang memiliki beberapa repositori git dengan remote yang menunjuk ke github. Tanpa ssh-agent berjalan dalam sesi layar, saya harus memasukkan frasa sandi untuk kunci saya untuk melakukan "git pull origin master". Booo! Selain itu, saya harus menginstal kunci pribadi saya di server jauh - Boooo lagi!

Sebagai gantinya, cukup menggunakan ssh -A [user@]remotehostpass di sepanjang ssh-agent saya yang berjalan secara lokal. Sekarang, saya tidak lagi memerlukan kunci pribadi saya untuk bahkan ada di host jarak jauh. Saya tidak percaya Anda perlu melakukan skrip sama sekali dengan ssh-agent.

Inilah yang cukup bagus yang bekerja di Cygwin juga:

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

Tambahkan ke .bash_profile atau .bashrc Anda

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

Coba gunakan gantungan kunci, itu dibuat untuk itu. http://www.gentoo.org/doc/en/keychain-guide.xml

Saya baru-baru ini mulai menggunakan:

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

Yang harus saya lakukan adalah menambahkan:

  alias ssh=/path/to/ssh-ident

Dalam file .bashrc saya. Skrip menangani:

• membuat agen saat pertama kali dibutuhkan
• muat kunci yang diperlukan sesuai permintaan
• agen berbagi di beberapa sesi login
• kelola beberapa agen, satu untuk setiap 'identitas' yang saya gunakan online, dan gunakan agen yang tepat berdasarkan host yang saya hubungkan atau direktori kerja saat ini.

Saya lebih suka menjaga hal-hal sesederhana mungkin: (cuplikan dari ~/.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
}

Saya tidak berpikir untuk menggunakan -asebelumnya, tetapi mungkin lebih mudah:

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

Dalam kasus saya, saya memiliki pengaturan posh-git di PowerShell dan ingin cygwin menggunakan ssh-agent yang sama. Saya harus melakukan manipulasi path karena mereka menggunakan folder tmp yang berbeda, dan file .env yang dibuat adalah UTF16 dengan BOM dan CR \ LF sehingga menyenangkan untuk ditangani. Menambahkan berikut ini ke .bashrc yang digunakan oleh cygwin seharusnya berfungsi:

# 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

Sekali lagi contoh untuk dimasukkan ke dalam .bash_profile Anda segera dan meminta untuk menambahkan kunci default Anda saat masuk. Penerusan bukan opsi dalam kasus saya.

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

Ini solusi saya, diadaptasi dari https://superuser.com/a/141233/5255 (di utas ini):

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

buat file ~ / 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

termasuk file dalam .bashrc

. ~/ssh-agent.sh

Ini adalah sesuatu yang saya tambahkan yang berfungsi untuk saya. Pertama-tama memeriksa untuk melihat apakah Anda memiliki agen berjalan, jika ya itu akan mengatur lingkungan yang tepat untuk itu, jika tidak itu akan membuatnya. Juga menghilangkan pembuatan agen tambahan:

Masukkan saja ke dalam .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

Saya memiliki variasi pada masalah ini, juga diambil langsung dari .bashrc saya:

# 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

Solusi ini menyimpan salinan informasi agen SSH di direktori home Anda. Jika Anda memiliki direktori home NFS-automounted yang mungkin dibagikan di antara banyak host, nama host digunakan sebagai bagian dari nama file untuk membedakannya, jadi masuk dari satu mesin tidak akan mengganggu file agen yang digunakan pada yang lain.

Tingkah laku:

1) Sesi pengguna pertama kali diminta untuk frasa sandi utama.

2) Sesi kedua, ketiga dan keempat (dan lain-lain) mewarisi agen dan kunci SSH yang ditambahkan pada yang pertama.

3) Jika agen terbunuh atau lumpuh, sesi berikutnya pertama akan membuat agen baru, menimpa file agen dengan yang baru - dan meminta kata sandi kunci lagi. Sesi yang dibuat selanjutnya akan berperilaku seperti skenario 2), selama agen SSH baru tetap berjalan.

(ini merujuk pada posting 2 yang lebih tinggi, saya tidak dapat menambahkan komentar)

@ raghavan: Contoh Anda bermanfaat, tetapi akan menyarankan untuk mengubah dua baris yang ada

pgrep ssh-agent

untuk

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

sehingga hanya agen yang berjalan di bawah pengguna saat ini yang ditemukan, dan pid tidak bergema ke layar (bersih).

Juga disarankan untuk mengubah $ HOME / ssh-agent.out menjadi $ HOME / .ssh-agent.out

Salam

Saya membaca solusi asli Anda dan sejumlah yang disarankan, tetapi memutuskan untuk menyederhanakan prosesnya untuk saya gunakan sendiri. Ini yang saya tambahkan di .bashrc saya sendiri:

    # 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

Saya telah membuat beberapa asumsi di sini:

• Bahwa direktori ~ / .ssh ada.
• Anda hanya menginginkan satu soket ssh-agent per pengguna di sistem.
• Variabel lingkungan HOME diatur (karena mengapa tidak, kan?).
• Bahwa Anda akan secara manual menangani situasi di mana ada proses yang berjalan, tetapi karena alasan tertentu tidak menggunakan file socket yang ditunjuk.

Secara keseluruhan saya pikir ini terasa seperti solusi sederhana.

Saya menemukan bahwa saya sering menjalankan banyak ssh-agentproses, dan PID di dalam nama file soket tidak pernah benar-benar cocok dengan PID yang sedang berjalan ssh-agent, jadi saya meretas sesuatu untuk mencoba memulihkan dari kondisi ini, berdasarkan banyak contoh di atas.

Ini adalah fungsi tunggal, ia menggunakan variabel Zsh untuk ID pengguna jika ada di sana, dan mencoba menghabiskan lebih sedikit waktu untuk mem-parsing /tmpdirektori yang mungkin sangat besar dengan membatasi find(1)sedikit lebih banyak.

Mungkin masih rawan kesalahan, dan berbelit-belit, tetapi beberapa tes sepintas menunjukkan sebagian besar berfungsi untuk kasus penggunaan saya, jadi begini:

attach_ssh_agent () {
  jika [-n "$ SSH_AGENT_PID"]; kemudian
    ssh-add -l> / dev / null
    ret = $?
    if [$ ret -ge 2]; kemudian
      echo "Agen pid $ SSH_AGENT_PID kurang berguna (ret = $ ret) - membunuh ..."
      bunuh $ SSH_AGENT_PID
      batalkan $ SSH_AGENT_PID
    elif [$ ret = 1]; kemudian
      echo "Agen pid $ SSH_AGENT_PID kurang berguna (ret = $ ret) - akan menaburnya ..."
    lain
      echo "Agen pid $ SSH_AGENT_PID"
      kembali
    fi
  fi
  jika [-S "$ SSH_AUTH_SOCK"]; kemudian
    ssh-add -l> / dev / null
    ret = $?
    if [$ ret = 2]; kemudian
      echo "Socket $ SSH_AUTH_SOCK sudah mati - menghapus ..."
      rm -f $ SSH_AUTH_SOCK
      batalkan SSH_AUTH_SOCK
    elif [$ ret = 1]; kemudian
      echo "Socket $ SSH_AUTH_SOCK menunjuk ke agen tanpa kunci ..."
      ssh-add
    lain
      echo "Ditemukan ssh-agent $ SSH_AUTH_SOCK (ret = $ ret)"
      kembali
    fi
  fi
  untuk sf dalam $ (temukan / tmp / -menghasilkan 2 -maxdepth 2-cair $ {UID: - $ (id -u)} -path '/tmp/ssh-*/agent.*' -type s); melakukan
    test -r $ sf || terus
    ekspor SSH_AUTH_SOCK = $ sf
    SSH_AGENT_PID = $ (nama samaran $ SSH_AUTH_SOCK | cut -d. -F2)
    # balapan dengan garpu proses lainnya, argh
    coba = 50
    sementara [$ try -gt 0]; melakukan
      coba = $ (($ coba-1))
      ekspor SSH_AGENT_PID = $ (($ SSH_AGENT_PID + 1))
      echo "Menguji $ SSH_AUTH_SOCK -> $ SSH_AGENT_PID"
      ssh_agent_running = $ (ps -u $ USER | grep ssh-agent)
      jika [-z "$ ssh_agent_running"]; kemudian
        echo "Socket $ SSH_AUTH_SOCK tidak mengandung tautan ke agen yang sedang berjalan - menghapus ..."
        rm -f $ SSH_AUTH_SOCK
        terus
      fi
      jika echo "$ ssh_agent_running" | \
           awk '$ 1 ==' $ SSH_AGENT_PID '{
                  ditemukan = 1;
                  keluar (0);
              }
              AKHIR {
                  jika ketemu) {
                      print "tidak menemukan menjalankan PID '$ SSH_AGENT_PID'";
                      keluar (1);
                  }
              } '; kemudian
        ssh-add -l> / dev / null
        ret = $?
        if [$ ret -ge 2]; kemudian
          echo "Socket $ SSH_AUTH_SOCK tidak mengandung tautan ke agen yang bermanfaat di $ SSH_AGENT_PID - menghapus ..."
          rm -f $ SSH_AUTH_SOCK
          bunuh $ SSH_AGENT_PID
          batalkan SSH_AGENT_PID
          lanjutkan 2
        elif [$ ret = 1]; kemudian
          echo "Socket $ SSH_AUTH_SOCK berisi tautan ke agen yang kurang bermanfaat di $ SSH_AGENT_PID - seeding ..."
          ssh-add
          jika! ssh-add -l> / dev / null; kemudian
            echo "Socket $ SSH_AUTH_SOCK masih mengandung tautan ke agen yang kurang bermanfaat di $ SSH_AGENT_PID - batalkan."
            kembali
          lain
            istirahat
          fi
        lain
          istirahat
        fi
      lain
# echo "Tidak dapat mencocokkan soket $ SSH_AUTH_SOCK dengan agen PID $ SSH_AGENT_PID - melewatkan ..."
        terus
      fi
    Selesai
    if [$ try -gt 0]; kemudian
      echo "Ditemukan ssh-agent $ SSH_AUTH_SOCK"
      echo "Agen pid $ SSH_AGENT_PID"
      kembali
    fi
  Selesai
  jika [-n "$ try" -a -n "$ SSH_AUTH_SOCK" -a -n "$ ssh_agent_running"]; kemudian
    echo "Kami mencoba berkali-kali, tetapi tidak dapat mencocokkan $ SSH_AUTH_SOCK dengan agen yang menjalankannya, desah"
    echo "$ ssh_agent_running"
    gema "Meninggalkan sisa makanan ini di belakang dan memulai agen baru ..."
  fi
  eval $ (ssh-agent -t 28800)
  ssh-add
}

Inilah putaran saya tentang ini. Saya ' sumber ' skrip di bawah ini dari .bash_profile saya :

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

Berikut ini skrip sederhana yang akan selalu menggunakan kembali ssh-agent yang sama, atau memulai ssh-agent jika tidak berjalan. Kuncinya adalah menggunakan -aopsi untuk menggunakan nama soket yang sama. Jika tidak, secara default akan memilih nama soket acak setiap kali. Anda dapat dengan mudah menggabungkan 3 baris ini menjadi alias 1 baris juga.

# 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

sumber