Condivisione dello stesso `ssh-agent` tra più sessioni di accesso


62

Esiste un modo conveniente per garantire che tutti gli accessi da un determinato utente (cioè me) utilizzino lo stesso agente ssh? Ho hackerato una sceneggiatura per farlo funzionare la maggior parte del tempo, ma sospettavo sempre che ci fosse un modo per farlo che mi ero appena perso. Inoltre, da quel momento ci sono stati incredibili progressi nella tecnologia informatica, come ad esempio questo sito Web.

Quindi l'obiettivo qui è quello

  • ogni volta che accedo al box, indipendentemente dal fatto che sia tramite SSH o in una sessione grafica avviata da gdm / kdm / etc, o da una console:
    • se il mio nome utente non è attualmente in ssh-agentesecuzione, ne viene avviato uno, le variabili di ambiente esportate e ssh-addchiamate.
    • in caso contrario, le coordinate dell'agente esistente vengono esportate nelle variabili di ambiente della sessione di accesso.

Questa funzione è particolarmente utile quando la casella in questione viene utilizzata come punto di inoltro quando si sshinserisce in una terza casella. In questo caso evita di dover digitare la passphrase della chiave privata ogni volta che si immette e quindi si desidera, ad esempio, fare git pusho qualcosa del genere.

Lo script fornito di seguito lo fa in gran parte in modo affidabile, anche se recentemente è andato in rovina quando X è andato in crash e ho quindi iniziato un'altra sessione grafica. In quel caso potrebbero esserci stati altri problemi.

Ecco la mia sceneggiatura cattiva. Ho preso questo dal mio .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;

Per favore, dimmi che c'è un modo migliore per farlo. Inoltre, per favore non pungere incoerenze / gaffes (es. Mettere varcose etc); L'ho scritto qualche tempo fa e da allora ho imparato molte cose.


1
KeyError: 'DWTFYWT' non trovato; intendevi WTFPLv2 ?
Grawity

@grawity: grazie per quel link, le loro FAQ hanno reso la mia giornata: A proposito, con il WTFPL, posso anche ... Oh ma sì, certo che puoi. Ma posso ... Sì, puoi. Può ... Sì! hahahahahaha
Quack Quixote

@grawity: No, è proprio quello che volevo farti pensare, mwahahaha.
intuito

Risposte:


25

Potrei anche gettare la mia variazione nel mix:

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"

E poi ogni volta che eseguo l'accesso, se voglio un agente collegato (che non sempre), scrivo e basta sagent.


2
if [ ! -x "$(which ssh-add)" ];dovrebbe essere sostituito con if ! which ssh-add;o if ! command -v ssh-add. (Ricorda, [è solo un comando)
gravità

Bene, puoi farlo, ma in realtà dovrebbe essere if ! which ssh-add > /dev/nullper impedire la stampa del percorso, a quel punto non sono davvero sicuro che sia più chiaro, anche se suppongo che ti salvi un ulteriore richiamo di comando.
Zed,

quindi sostanzialmente la risposta è no, quindi. una schifezza. Bene, questo sembra essere più evoluto del mio hack, quindi probabilmente sarà utile. Strano che non ci sia un modo più strutturato di farlo, sembra qualcosa che sarebbe abbastanza utile.
intuito

Sono in procinto di riposizionare tutto in questi giorni, quindi ho creato un repository github per la tua sceneggiatura. Grazie ancora. Spero di essere stato abbastanza formale con le licenze: ~ /
intuito il

Non mi dispiace Per favore, commenta qui se qualcuno lo sottopone a miglioramenti.
Zed,

36

ssh -A [user@]remotehost

Penso che questo potrebbe essere quello che stai cercando. Utilizzare l'opzione -A quando si esegue ssh in avanti ssh-agent. Ecco un esempio:

Ho un server remoto che ha alcuni repository git su di esso con un telecomando che punta a github. Senza un agente ssh in esecuzione in una sessione dello schermo, devo inserire la passphrase per la mia chiave per fare un "master git pull origin". Booo! Inoltre, devo avere la mia chiave privata installata sul server remoto - più Boooo!

Invece, semplicemente usando i ssh -A [user@]remotehostpassaggi lungo il mio ssh-agent in esecuzione localmente. Ora, non ho più bisogno che la mia chiave privata esista anche sull'host remoto. Non credo che tu debba fare alcun script con ssh-agent.


4
Non lo sapevo, ma si è rivelato esattamente quello che stavo cercando quando sono arrivato a questa domanda.
Will McCutchen,

1
Questo è persino meglio di quello che stavo cercando! Bella risposta!
WhyNotHugo,

1
Vedi anche man 5 ssh_configper le ForwardAgentimpostazioni di configurazione. Abilita l'inoltro dell'agente per impostazione predefinita, eliminando la necessità -Adell'argomento. Prima di utilizzare l'inoltro agente, tenere presente che esiste un rischio per la sicurezza in cui altri utenti privilegiati sul computer remoto potrebbero accedere al socket dell'agente inoltrato. Questo è anche menzionato nella pagina man. Questo è spiegato bene qui .
Starfry,

Penso che l'opzione AllowAgentForwarding debba essere impostata su yes sul server, però
Ziofil

20

Eccone uno carino che funziona anche su 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

Aggiungilo al tuo .bash_profile o .bashrc

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


Funziona bene anche con Git Bash (mingw64) per Windows
Dolphin

1
${SSH_ENV}deve essere "${SSH_ENV}"se il nome utente di Windows ha uno spazio al suo interno
rgvcorley,

Questa risposta sembra rimbalzare su Internet. Eccolo su un thread stackoverflow molto più grande . L'approccio migliore / più semplice IMHO.
Luke Davis,


6

Di recente ho iniziato a utilizzare:

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

Tutto quello che devo fare è aggiungere:

  alias ssh=/path/to/ssh-ident

Nel mio file .bashrc. La sceneggiatura si occupa di:

  • creando un agente quando è necessario per la prima volta
  • caricare le chiavi necessarie su richiesta
  • condividere agenti attraverso più sessioni di accesso
  • gestire più agenti, uno per ogni "identità" che utilizzo online e utilizzare l'agente giusto in base all'host a cui mi sto collegando o alla directory di lavoro corrente.

ssh-ident è fantastico! Sblocca la chiave e carica l'agente quando provo a ssh invece di dover sbloccare la chiave in anticipo. Ciò rende utili i timeout chiave. Ancora più importante, mantiene i miei agenti separati per diversi usi (un grave rischio per la sicurezza; il root su una macchina ha il mio livello di accesso a tutte le altre macchine per le quali l'agente attuale ha le chiavi!)
00prometheus

5

Preferisco mantenere le cose il più semplice possibile: (frammento di ~/.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
}

Non pensavo di usare -aprima, ma potrebbe essere più semplice:

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

Bello. L'ho semplificato in qualche modo nella mia risposta (sotto).
Ether

2

Nel mio caso, ho installato Posh-git in PowerShell e volevo che Cygwin usasse lo stesso agente SSH. Ho dovuto fare un po 'di manipolazione del percorso poiché usano diverse cartelle tmp e il file .env creato era UTF16 con BOM e CR \ LF, quindi è stato divertente affrontarlo. L'aggiunta di quanto segue al .bashrc utilizzato da Cygwin dovrebbe funzionare:

# 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

1

Ancora un esempio per inserire immediatamente il tuo .bash_profile e chiedendo di aggiungere la tua chiave predefinita all'accesso. L'inoltro non era un'opzione nel mio 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

1

Questa è la mia soluzione, adattata da https://superuser.com/a/141233/5255 (in questa discussione):

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

1

crea il 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

includere il file in .bashrc

. ~/ssh-agent.sh

0

Questo è qualcosa che ho aggiunto che funziona per me. Per prima cosa controlla se hai un agente in esecuzione, se sì imposta gli ambienti corretti per esso, in caso contrario lo creerà. Elimina anche la creazione di agenti extra:

Mettilo nel tuo .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

0

Ho anche una variazione su questo problema, presa direttamente dal mio .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

Questa soluzione memorizza una copia delle informazioni sull'agente SSH nella directory principale. Nel caso in cui si disponga di una home directory montata su NFS che potrebbe essere condivisa tra più host, il nome host viene utilizzato come parte del nome file per differenziarsi tra loro, quindi l'accesso da una macchina non bloccherà il file dell'agente in uso su un'altra.

Comportamento:

1) Le sessioni utente per la prima volta richiedono una passphrase chiave.

2) Le sessioni della seconda, terza e quarta (eccetera) ereditano l'agente SSH e le chiavi aggiunte nella prima.

3) Se l'agente viene ucciso o si arresta in modo anomalo, la prima sessione successiva creerà un nuovo agente, sovrascriverà il file dell'agente con quello nuovo e richiederà nuovamente una passphrase della chiave. Le sessioni create successivamente si comporteranno come lo scenario 2), purché il nuovo agente SSH rimanga in esecuzione.


0

(questo si riferisce al post 2 in alto, non sono stato in grado di aggiungere un commento)

@raghavan: il tuo esempio è utile, ma suggerirei di cambiare le due righe che hanno

pgrep ssh-agent

per

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

in modo che vengano trovati solo gli agenti in esecuzione sotto l'utente corrente e il pid non venga ripetuto sullo schermo (più pulito).

Suggerirei anche di cambiare $ HOME / ssh-agent.out in $ HOME / .ssh-agent.out

Saluti


0

Ho letto la tua soluzione originale e un numero di quelli suggeriti, ma ho deciso di semplificare il processo per uso personale. Questo è ciò che ho aggiunto nel mio .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

Ho fatto un paio di ipotesi qui:

  • Che esiste la directory ~ / .ssh.
  • Che si desidera un solo socket ssh-agent per utente sul sistema.
  • Che la variabile d'ambiente HOME sia impostata (perché, perché no, giusto?).
  • Che gestirai manualmente una situazione in cui è in esecuzione un processo, ma per qualche motivo non utilizza il file socket designato.

Tutto sommato, penso che sia una soluzione semplice.


0

Ho scoperto che spesso avevo più ssh-agentprocessi in esecuzione e che il PID all'interno del nome del file del socket non corrispondeva mai effettivamente al PID di una corsa ssh-agent, quindi ho hackerato qualcosa per provare a recuperare da queste condizioni, sulla base di numerosi esempi sopra.

È una singola funzione, utilizza una variabile Zsh per l'ID utente se è presente e cerca di dedicare meno tempo all'analisi di /tmpdirectory potenzialmente possibili limitando find(1)un po 'di più.

Probabilmente è ancora soggetto a errori e contorto, ma alcuni test corsivi indicano che funziona principalmente per i miei casi d'uso, quindi ecco qui:

attach_ssh_agent () {
  if [-n "$ SSH_AGENT_PID"]; poi
    ssh-add -l> / dev / null
    ret = $?
    if [$ ret -ge 2]; poi
      echo "Il pid $ SSH_AGENT_PID dell'agente è poco utile (ret = $ ret) - uccidere ..."
      uccidi $ SSH_AGENT_PID
      unset $ SSH_AGENT_PID
    elif [$ ret = 1]; poi
      echo "Il pid $ SSH_AGENT_PID dell'agente è poco utile (ret = $ ret) - lo eseguirà il seeding ..."
    altro
      echo "Agente pid $ SSH_AGENT_PID"
      ritorno
    fi
  fi
  se [-S "$ SSH_AUTH_SOCK"]; poi
    ssh-add -l> / dev / null
    ret = $?
    se [$ ret = 2]; poi
      echo "Il socket $ SSH_AUTH_SOCK è morto - eliminazione in corso ..."
      rm -f $ SSH_AUTH_SOCK
      non impostato SSH_AUTH_SOCK
    elif [$ ret = 1]; poi
      echo "Il socket $ SSH_AUTH_SOCK punta a un agente senza chiavi ..."
      ssh-add
    altro
      echo "Trovato ssh-agent $ SSH_AUTH_SOCK (ret = $ ret)"
      ritorno
    fi
  fi
  per sf in $ (find / tmp / -mindepth 2 -maxdepth 2 -uid $ {UID: - $ (id -u)} -path '/tmp/ssh-*/agent.*' -type s); fare
    test -r $ sf || Continua
    export SSH_AUTH_SOCK = $ sf
    SSH_AGENT_PID = $ (basename $ SSH_AUTH_SOCK | cut -d. -F2)
    # gareggia con altre forcelle di processo, argh
    provare = 50
    mentre [$ try -gt 0]; fare
      provare = $ (($ try-1))
      export SSH_AGENT_PID = $ (($ SSH_AGENT_PID + 1))
      echo "Test di $ SSH_AUTH_SOCK -> $ SSH_AGENT_PID"
      ssh_agent_running = $ (ps -u $ USER | grep ssh-agent)
      if [-z "$ ssh_agent_running"]; poi
        echo "Socket $ SSH_AUTH_SOCK non contiene un collegamento a nessun agente in esecuzione - eliminazione in corso ..."
        rm -f $ SSH_AUTH_SOCK
        Continua
      fi
      se echo "$ ssh_agent_running" | \
           awk '$ 1 ==' $ SSH_AGENT_PID '{
                  Found = 1;
                  exit (0);
              }
              FINE {
                  se trovato) {
                      print "non ha trovato PID '$ SSH_AGENT_PID' in esecuzione;";
                      exit (1);
                  }
              } '; poi
        ssh-add -l> / dev / null
        ret = $?
        if [$ ret -ge 2]; poi
          echo "Il socket $ SSH_AUTH_SOCK non contiene un collegamento a un agente utile in $ SSH_AGENT_PID - eliminazione in corso ..."
          rm -f $ SSH_AUTH_SOCK
          uccidi $ SSH_AGENT_PID
          disinserito SSH_AGENT_PID
          continua 2
        elif [$ ret = 1]; poi
          echo "Il socket $ SSH_AUTH_SOCK contiene un collegamento a un agente poco utile in $ SSH_AGENT_PID - seeding ..."
          ssh-add
          Se ! ssh-add -l> / dev / null; poi
            echo "Il socket $ SSH_AUTH_SOCK contiene ancora un collegamento a un agente poco utile a $ SSH_AGENT_PID - interruzione."
            ritorno
          altro
            rompere
          fi
        altro
          rompere
        fi
      altro
# echo "Impossibile associare il socket $ SSH_AUTH_SOCK all'agente PID $ SSH_AGENT_PID - saltando ..."
        Continua
      fi
    fatto
    if [$ try -gt 0]; poi
      echo "Trovato ssh-agent $ SSH_AUTH_SOCK"
      echo "Agente pid $ SSH_AGENT_PID"
      ritorno
    fi
  fatto
  if [-n "$ try" -a -n "$ SSH_AUTH_SOCK" -a -n "$ ssh_agent_running"]; poi
    echo "Ci abbiamo provato molte volte, ma non è stato possibile abbinare $ SSH_AUTH_SOCK a nessuno degli agenti in esecuzione, sospiro"
    echo "$ ssh_agent_running"
    echo "Lasciando indietro questi avanzi e avviando un nuovo agente ..."
  fi
  eval $ (ssh-agent -t 28800)
  ssh-add
}

0

Ecco il mio giro su questo. Ho ' fonte ' lo script seguente dal mio .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

0

Ecco un semplice script che riutilizzerà sempre lo stesso ssh-agent o avvierà ssh-agent se non è in esecuzione. La chiave è utilizzare l' -aopzione per utilizzare lo stesso nome socket. Altrimenti, per impostazione predefinita sceglierà ogni volta un nome di socket casuale. Puoi facilmente combinare anche queste 3 linee in un alias di 1 linea.

# 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

fonte

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.