Iniciar ssh-agent no login

Eu tenho um site como um repositório Git remoto, retirando do Bitbucket.com usando um alias SSH. Posso iniciar manualmente o ssh-agent no meu servidor, mas preciso fazer isso toda vez que faço login via SSH.

Inicio manualmente o ssh-agent:

eval ssh-agent $SHELL

Então eu adiciono o agente:

ssh-add ~/.ssh/bitbucket_id

Então ele aparece quando eu faço:

ssh-add -l

E eu estou pronto para ir. Existe alguma maneira de automatizar esse processo para que eu não precise fazer isso toda vez que fizer login? O servidor está executando o RedHat 6.2 (Santiago).

Por favor, leia este artigo. Você pode achar isso muito útil:

http://mah.everybody.org/docs/ssh

Caso o link acima desapareça algum dia, estou capturando a parte principal da solução abaixo:

Esta solução de Joseph M. Reagle por Daniel Starin:

Adicione o seguinte ao seu .bash_profile

SSH_ENV="$HOME/.ssh/agent-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 -ef | grep ${SSH_AGENT_PID} | grep ssh-agent$ > /dev/null || {
        start_agent;
    }
else
    start_agent;
fi

Esta versão é especialmente interessante, pois ela verificará se você já iniciou o ssh-agent e, se não conseguir encontrá-la, iniciará e armazenará as configurações para que possam ser usadas na próxima vez que você iniciar um Concha.

No Arch Linux, o seguinte funciona muito bem (deve funcionar em todas as distribuições baseadas em systemd):

Crie um serviço de usuário systemd, colocando o seguinte em ~/.config/systemd/user/ssh-agent.service:

[Unit]
Description=SSH key agent

[Service]
Type=simple
Environment=SSH_AUTH_SOCK=%t/ssh-agent.socket
ExecStart=/usr/bin/ssh-agent -D -a $SSH_AUTH_SOCK

[Install]
WantedBy=default.target

Shell de instalação para ter uma variável de ambiente para o soquete ( .bash_profile, .zshrc, ...):

export SSH_AUTH_SOCK="$XDG_RUNTIME_DIR/ssh-agent.socket"

Ative o serviço, para que ele seja iniciado automaticamente no login e inicie-o:

systemctl --user enable ssh-agent
systemctl --user start ssh-agent

Adicione a seguinte configuração ao seu arquivo de configuração ssh local ~/.ssh/config(isso funciona desde o SSH 7.2):

AddKeysToAgent  yes

Isso instruirá o cliente ssh a sempre adicionar a chave a um agente em execução, portanto, não há necessidade de adicioná-la previamente.

Pergunta antiga, mas me deparei com uma situação semelhante. Não pense que a resposta acima alcança completamente o que é necessário. A peça que falta é keychain; instale-o se ainda não estiver.

sudo apt-get install keychain

Em seguida, adicione a seguinte linha ao seu ~/.bashrc

eval $(keychain --eval id_rsa)

Isso iniciará ssh-agentse não estiver em execução, conecte-se a ele, carregue ossh-agent variáveis ​​de ambiente em seu shell e carregue sua chave ssh.

Altere id_rsapara a chave privada em~/.ssh você deseja carregar.

Referência

/unix/90853/how-can-i-run-ssh-add-automatically-without-password-prompt

A solução aceita possui as seguintes desvantagens:

• é complicado de manter;
• avalia o arquivo de armazenamento que pode levar a erros ou violação de segurança;
• ele inicia o agente, mas não o interrompe, o que é equivalente a deixar a chave na ignição.

Se suas chaves não exigirem digitar a senha, sugiro a seguinte solução. Adicione o seguinte ao seu .bash_profile final (edite a lista de chaves de acordo com suas necessidades):

exec ssh-agent $BASH -s 10<&0 << EOF
    ssh-add ~/.ssh/your_key1.rsa \
            ~/.ssh/your_key2.rsa &> /dev/null
    exec $BASH <&10-
EOF

Tem as seguintes vantagens:

• solução muito mais simples;
• a sessão do agente termina quando a sessão do bash termina.

Tem possíveis desvantagens:

• interativo ssh-add comando influenciará apenas uma sessão, o que é de fato um problema apenas em circunstâncias muito atípicas;
• inutilizável se a digitação da senha for necessária;
• O shell iniciado se torna não-login (o que não influencia em nada o AFAIK).

Observe que vários ssh-agentprocessos não são uma desvantagem, porque eles não levam mais memória ou tempo de CPU.

Adicione isso ao seu e ~/.bashrc, em seguida, efetue logout e entre novamente para entrar em vigor.

if [ ! -S ~/.ssh/ssh_auth_sock ]; then
  eval `ssh-agent`
  ln -sf "$SSH_AUTH_SOCK" ~/.ssh/ssh_auth_sock
fi
export SSH_AUTH_SOCK=~/.ssh/ssh_auth_sock
ssh-add -l > /dev/null || ssh-add

Isso deve solicitar apenas uma senha na primeira vez que você fizer login após cada reinicialização. Ele continuará reutilizando o mesmo ssh-agentenquanto permanecer em execução.

Então, eu costumava usar as abordagens descritas acima, mas eu meio que prefiro que o agente morra quando minha última sessão do bash termina. Isso é um pouco mais longo que as outras soluções, mas é a minha abordagem preferida. A idéia básica é que a primeira sessão do bash inicie o ssh-agent. Em seguida, cada sessão bash adicional verifica o arquivo de configuração ( ~/.ssh/.agent_env). Se houver e houver uma sessão em execução, origine o ambiente e crie um hardlink para o arquivo de soquete /tmp(precisa estar no mesmo sistema de arquivos que o arquivo de soquete original). À medida que as sessões do bash são encerradas, cada uma exclui seu próprio hardlink. A última sessão a ser concluída constatará que os hardlinks possuem 2 links (o hardlink e o original), a remoção do soquete do próprio processo e a eliminação do processo resultarão em 0, deixando um ambiente limpo após o fechamento da última sessão do bash.

# Start ssh-agent to keep you logged in with keys, use `ssh-add` to log in
agent=`pgrep ssh-agent -u $USER` # get only your agents           
if [[ "$agent" == "" || ! -e ~/.ssh/.agent_env ]]; then
    # if no agents or environment file is missing create a new one
    # remove old agents / environment variable files
    kill $agent running
    rm ~/.ssh/.agent_env 

    # restart
    eval `ssh-agent` 
    echo 'export SSH_AUTH_SOCK'=$SSH_AUTH_SOCK >> ~/.ssh/.agent_env             
    echo 'export SSH_AGENT_PID'=$SSH_AGENT_PID >> ~/.ssh/.agent_env             
fi

# create our own hardlink to the socket (with random name)           
source ~/.ssh/.agent_env                                                    
MYSOCK=/tmp/ssh_agent.${RANDOM}.sock                                        
ln -T $SSH_AUTH_SOCK $MYSOCK                                                
export SSH_AUTH_SOCK=$MYSOCK                                                

end_agent()                                                                     
{
    # if we are the last holder of a hardlink, then kill the agent
    nhard=`ls -l $SSH_AUTH_SOCK | awk '{print $2}'`                             
    if [[ "$nhard" -eq 2 ]]; then                                               
        rm ~/.ssh/.agent_env                                                    
        ssh-agent -k                                                            
    fi                                                                          
    rm $SSH_AUTH_SOCK                                                           
}                                                                               
trap end_agent EXIT                                                             
set +x              

Só para acrescentar mais uma solução: P, fui com uma combinação das soluções @spheenik e @ collin-anderson.

 # Ensure that we have an ssh config with AddKeysToAgent set to true
 if [ ! -f ~/.ssh/config ] || ! cat ~/.ssh/config | grep AddKeysToAgent | grep yes > /dev/null; then
     echo "AddKeysToAgent  yes" >> ~/.ssh/config
 fi
 # Ensure a ssh-agent is running so you only have to enter keys once
 if [ ! -S ~/.ssh/ssh_auth_sock ]; then
   eval `ssh-agent`
   ln -sf "$SSH_AUTH_SOCK" ~/.ssh/ssh_auth_sock
 fi
 export SSH_AUTH_SOCK=~/.ssh/ssh_auth_sock

Poderia ser um pouco mais elegante, mas é simples e legível. Esta solução:

• garante que AddKeysToAgent yesestá em sua configuração ssh, para que as chaves sejam adicionadas automaticamente após o uso
• não solicita a inserção de senhas no login (novamente, a inserção de senhas únicas ocorre no primeiro uso)
• silenciosamente inicia um agente ssh se ele ainda não iniciou um

Comentários bem-vindos :)

Eu o resolvi adicionando isso ao / etc / profile - em todo o sistema (ou ao usuário local .profile ou _.bash_profile_):

# SSH-AGENT 
#!/usr/bin/env bash
SERVICE='ssh-agent'
WHOAMI=`who am i |awk '{print $1}'`

if pgrep -u $WHOAMI $SERVICE >/dev/null
then
    echo $SERVICE running.
else
    echo $SERVICE not running.
    echo starting
    ssh-agent > ~/.ssh/agent_env
fi
. ~/.ssh/agent_env

Isso inicia um novo ssh-agent se não estiver em execução para o usuário atual ou reconfigura o parâmetro env ssh-agent se estiver em execução.

Os usuários do shell de peixe podem usar esse script para fazer a mesma coisa.

# content has to be in .config/fish/config.fish
# if it does not exist, create the file
setenv SSH_ENV $HOME/.ssh/environment

function start_agent                                                                                                                                                                    
    echo "Initializing new SSH agent ..."
    ssh-agent -c | sed 's/^echo/#echo/' > $SSH_ENV
    echo "succeeded"
    chmod 600 $SSH_ENV 
    . $SSH_ENV > /dev/null
    ssh-add
end

function test_identities                                                                                                                                                                
    ssh-add -l | grep "The agent has no identities" > /dev/null
    if [ $status -eq 0 ]
        ssh-add
        if [ $status -eq 2 ]
            start_agent
        end
    end
end

if [ -n "$SSH_AGENT_PID" ] 
    ps -ef | grep $SSH_AGENT_PID | grep ssh-agent > /dev/null
    if [ $status -eq 0 ]
        test_identities
    end  
else
    if [ -f $SSH_ENV ]
        . $SSH_ENV > /dev/null
    end  
    ps -ef | grep $SSH_AGENT_PID | grep -v grep | grep ssh-agent > /dev/null
    if [ $status -eq 0 ]
        test_identities
    else 
        start_agent
    end  
end

Eu uso a ferramenta ssh-ident para isso.

De sua página de manual :

ssh-ident - Inicie e use o ssh-agent e carregue as identidades conforme necessário.

Tentei algumas soluções de várias fontes, mas tudo parecia demais. Finalmente eu encontrei o mais fácil :)

Se você ainda não está familiarizado com o zsh e o oh-my-zsh , instale-o. Você vai adorar :)

Então edite .zshrc

vim ~/.zshrc

encontre a pluginsseção e atualize-a para usar da seguinte ssh-agentmaneira:

plugins=(ssh-agent git)

E isso é tudo! Você estará ssh-agentem funcionamento toda vez que iniciar seu shell

Eu gosto muito das suas respostas. Tornou o trabalho dos cygwin / linuxhosts muito mais fácil. Combinei as funções de início e fim para torná-lo seguro.

SSH_ENV="$HOME/.ssh/.agent_env"

function start_agent {
    echo "Initialising new SSH agent..."

    eval `/usr/bin/ssh-agent`
    echo 'export SSH_AUTH_SOCK'=$SSH_AUTH_SOCK >> ${SSH_ENV}
    echo 'export SSH_AGENT_PID'=$SSH_AGENT_PID >> ${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 -ef | grep ${SSH_AGENT_PID} | grep ssh-agent$ > /dev/null || {
        start_agent;
    }
else
    start_agent;
fi

# create our own hardlink to the socket (with random name)
MYSOCK=/tmp/ssh_agent.${RANDOM}.sock
ln -T $SSH_AUTH_SOCK $MYSOCK
export SSH_AUTH_SOCK=$MYSOCK

end_agent()
{
    # if we are the last holder of a hardlink, then kill the agent
    nhard=`ls -l $SSH_AUTH_SOCK | awk '{print $2}'`
    if [[ "$nhard" -eq 2 ]]; then
        rm ${SSH_ENV}
        /usr/bin/ssh-agent -k
    fi
    rm $SSH_AUTH_SOCK
}
trap end_agent EXIT
set +x