Compartilhando o mesmo 'ssh-agent' entre várias sessões de login

Question

Existe uma maneira conveniente de garantir que todos os logins de um determinado usuário (ou seja, eu) usem o mesmo ssh-agent? Eu hackeei um script para fazer este trabalho a maior parte do tempo, mas eu suspeitava o tempo todo que havia alguma maneira de fazer isso que eu tinha acabado de perder. Além disso, desde então, houve avanços surpreendentes em tecnologia de computação, como por exemplo este site.

Então o objetivo aqui é que

• sempre que eu fizer login na caixa, independentemente de ser via SSH ou em uma sessão gráfica iniciada a partir do gdm / kdm / etc, ou em um console:
  • se meu nome de usuário não tiver atualmente um ssh-agent em execução, um será iniciado, as variáveis de ambiente serão exportadas e ssh-add será chamado.
  • caso contrário, as coordenadas do agente existente serão exportadas nas variáveis de ambiente da sessão de login.

Este recurso é especialmente valioso quando a caixa em questão é usada como um ponto de retransmissão quando ssh ing em uma terceira caixa. Nesse caso, evita ter que digitar a senha da chave privada sempre que você digitar ssh e, por exemplo, desejar fazer git push ou algo assim.

O roteiro dado abaixo faz isso de forma mais confiável, embora tenha fracassado recentemente quando o X travou e eu iniciei outra sessão gráfica. Pode ter havido outro mal-estar acontecendo nesse caso.

Aqui está meu roteiro ruim é bom. Eu comprei isso do meu .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+).*$//''; 
    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, me diga que há uma maneira melhor de fazer isso. Também, por favor, não mostre as inconsistências / gafes (por exemplo, colocando var stuff em etc ); Eu escrevi isso há um tempo e desde então aprendi muitas coisas.

    

Answer 1

Eu também posso jogar minha própria variação no 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 então toda vez que eu fizer login, se eu quiser um agente anexado (o que eu nem sempre), eu apenas digite sagent .

    

Answer 2

ssh -A [user@]remotehost

Acho que isso pode ser o que você está procurando. Use a opção -A ao executar o ssh-forward em seu agente ssh. Aqui está uma usecase:

Eu tenho um servidor remoto que tem alguns git repos com um remoto apontando para o github. Sem um agente ssh em execução em uma sessão de tela, eu tenho que inserir a frase secreta para a minha chave, a fim de fazer um "mestre de origem git pull". Booo! Além disso, devo ter minha chave privada instalada no servidor remoto - mais Boooo!

Em vez disso, simplesmente usando ssh -A [user@]remotehost passa ao longo do meu ssh-agent localmente em execução. Agora, não preciso mais que minha chave privada exista no host remoto. Eu não acredito que você precise fazer nenhum script com o ssh-agent.

    

Answer 3

Aqui está um bom exemplo que também funciona no 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

Adicione ao seu .bash_profile ou .bashrc

Fonte: link

    

Answer 4

Tente usar o chaveiro, é feito para isso. link

    

Answer 5

Eu comecei recentemente a usar:

link

Tudo o que tenho que fazer é adicionar:

  alias ssh=/path/to/ssh-ident

No meu arquivo .bashrc. O roteiro cuida de:

• criando um agente quando é necessário pela primeira vez
• carregue as chaves necessárias sob demanda
• compartilhe agentes em várias sessões de login
• gerenciar vários agentes, um para cada 'identidade' que eu uso on-line e usar o agente certo com base no host ao qual estou me conectando ou no diretório de trabalho atual.

Answer 6

Eu prefiro manter as coisas o mais simples possível: (snippet 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
}

Eu não pensei em usar -a antes, mas pode ser mais 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

    

Answer 7

No meu caso eu tenho a configuração posh-git no PowerShell e queria que o cygwin usasse o mesmo ssh-agent. Eu tive que fazer alguma manipulação de caminho desde que eles usam pastas de tmp diferentes eo arquivo de .env criado era UTF16 com BOM e CR \ LF de forma que era divertido para lidar com. Adicionar o seguinte ao .bashrc usado pelo cygwin deve 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

    

Answer 8

Novamente, um exemplo para colocar seu .bash_profile imediatamente e pedir para adicionar sua chave padrão no logon. Encaminhamento não era uma opção no meu 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

    

Answer 9

Esta é a minha solução, adaptada do link (neste tópico):

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

    

Answer 10

crie o arquivo ~ / 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

inclua o arquivo em .bashrc

. ~/ssh-agent.sh

    

Answer 11

Isso é algo que eu adicionei e que funciona para mim. Primeiro ele verifica se você tem um agente em execução, se sim, ele irá configurar os ambientes apropriados para isso, se não, ele irá criá-lo. Também elimina a criação de agentes extras:

Basta colocar em seu .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

    

Answer 12

Também tenho uma variação deste problema, tirada diretamente do meu .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 solução armazena uma cópia das informações do agente SSH em seu diretório pessoal. Caso você tenha um diretório inicial montado automaticamente pelo NFS que possa ser compartilhado entre vários hosts, o nome do host é usado como parte do nome do arquivo para diferenciá-los, portanto, o login de uma máquina não afeta o arquivo do agente em uso em outra.

Comportamento:

1) As primeiras sessões do usuário são solicitadas por uma frase secreta chave.

2) As sessões de segundo, terceiro e quarto (et cetera) herdam o agente SSH e as chaves adicionadas no primeiro.

3) Se o agente for eliminado ou travar, a primeira sessão subseqüente criará um novo agente, sobrescreverá o arquivo do agente com o novo - e solicitará uma senha de chave novamente. As sessões criadas subseqüentemente se comportarão como o cenário 2), desde que o novo agente SSH continue em execução.

    

Answer 13

Descobri que muitas vezes eu tinha vários processos de ssh-agent em execução e que o PID dentro do nome do arquivo de soquete nunca correspondia ao PID de um ssh-agent , então hackeava algo para tentar recuperar dessas condições, com base em numerosos exemplos acima.

É uma única função, ele usa uma variável Zsh para o ID do usuário, se estiver lá, e tenta gastar menos tempo analisando possivelmente os diretórios /tmp , restringindo um pouco mais o find(1) .

Provavelmente ainda é propenso a erros e complicado, mas alguns testes superficiais indicam que ele funciona principalmente para os meus casos de uso, então aqui está:

attach_ssh_agent () {
  if [ -n "$SSH_AGENT_PID" ]; then
    ssh-add -l >/dev/null
    ret=$?
    if [ $ret -ge 2 ]; then
      echo "Agent pid $SSH_AGENT_PID is less than useful (ret=$ret) - killing..."
      kill $SSH_AGENT_PID
      unset $SSH_AGENT_PID
    elif [ $ret = 1 ]; then
      echo "Agent pid $SSH_AGENT_PID is less than useful (ret=$ret) - will be seeding it..."
    else
      echo "Agent pid $SSH_AGENT_PID"
      return
    fi
  fi
  if [ -S "$SSH_AUTH_SOCK" ]; then
    ssh-add -l > /dev/null
    ret=$?
    if [ $ret = 2 ]; then
      echo "Socket $SSH_AUTH_SOCK is dead - deleting..."
      rm -f $SSH_AUTH_SOCK
      unset SSH_AUTH_SOCK
    elif [ $ret = 1 ]; then
      echo "Socket $SSH_AUTH_SOCK points to an agent with no keys..."
      ssh-add
    else
      echo "Found ssh-agent $SSH_AUTH_SOCK (ret=$ret)"
      return
    fi
  fi
  for sf in $(find /tmp/ -mindepth 2 -maxdepth 2 -uid ${UID:-$(id -u)} -path '/tmp/ssh-*/agent.*' -type s); do
    test -r $sf || continue
    export SSH_AUTH_SOCK=$sf
    SSH_AGENT_PID=$(basename $SSH_AUTH_SOCK | cut -d. -f2)
    # races with other process forks, argh
    try=50
    while [ $try -gt 0 ]; do
      try=$(($try-1))
      export SSH_AGENT_PID=$(($SSH_AGENT_PID+1))
      echo "Testing $SSH_AUTH_SOCK -> $SSH_AGENT_PID"
      if ps -u $USER | grep ssh-agent | \
           awk '$1 == '$SSH_AGENT_PID' {
                  found=1;
                  exit(0);
              }
              END {
                  if (!found) {
                      print "did not find running PID '$SSH_AGENT_PID'";
                      exit(1);
                  }
              }'; then
        ssh-add -l > /dev/null
        ret=$?
        if [ $ret -ge 2 ]; then
          echo "Socket $SSH_AUTH_SOCK does not contain a link to a useful agent at $SSH_AGENT_PID - deleting..."
          rm -f $SSH_AUTH_SOCK
          kill $SSH_AGENT_PID
          unset SSH_AGENT_PID
          continue 2
        elif [ $ret = 1 ]; then
          echo "Socket $SSH_AUTH_SOCK contains a link to a less than useful agent at $SSH_AGENT_PID - seeding..."
          ssh-add
          if ! ssh-add -l > /dev/null; then
            echo "Socket $SSH_AUTH_SOCK still contains a link to a less than useful agent at $SSH_AGENT_PID - aborting."
            return
          else
            break
          fi
        else
          break
        fi
      else
        echo "Socket $SSH_AUTH_SOCK does not contain a link to a running agent - deleting..."
        rm -f $SSH_AUTH_SOCK
        continue
      fi
    done
    if [ $try -gt 0 ]; then
      echo "Found ssh-agent $SSH_AUTH_SOCK"
      echo "Agent pid $SSH_AGENT_PID"
      return
    fi
  done
  eval $(ssh-agent -t 14400)
  ssh-add
}

    

Answer 14

(isso se refere ao post 2 mais alto, não consegui adicionar um comentário)

@raghavan: Seu exemplo é útil, mas sugeriria alterar as duas linhas que têm

pgrep ssh-agent

para

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

para que apenas agentes que estão sendo executados sob o usuário atual sejam encontrados e o pid não seja exibido na tela (mais limpo).

Também sugeriria mudar $ HOME / ssh-agent.out para $ HOME / .ssh-agent.out

Atenciosamente

    

Answer 15

Eu li sua solução original e algumas das sugeridas, mas decidi simplificar o processo para meu próprio uso. Isto é o que eu adicionei no meu próprio .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

Eu fiz algumas suposições aqui:

• Que o diretório ~ / .ssh existe.
• Você deseja apenas um soquete ssh-agent por usuário no sistema.
• Que a variável de ambiente HOME está definida (porque, por que não, certo?).
• Você manipulará manualmente uma situação em que há um processo em execução, mas, por algum motivo, não usa o arquivo de soquete designado.

Em suma, acho que parece uma solução simples.