it-swarm.com.de

Starten Sie ssh-agent bei der Anmeldung

Ich habe eine Site als Remote-Git-Repo, die über einen SSH-Alias ​​von Bitbucket.com abgerufen wird. Ich kann den ssh-agent manuell auf meinem Server starten, muss dies jedoch jedes Mal tun, wenn ich mich über SSH anmelde.

Ich starte den ssh-agent manuell:

eval ssh-agent $Shell

Dann füge ich den Agenten hinzu:

ssh-add ~/.ssh/bitbucket_id

Dann zeigt es sich, wenn ich tue:

ssh-add -l

Und ich kann loslegen. Gibt es eine Möglichkeit, diesen Vorgang zu automatisieren, damit ich ihn nicht bei jeder Anmeldung erneut ausführen muss? Auf dem Server wird RedHat 6.2 (Santiago) ausgeführt.

216
Pathsofdesign

Bitte lesen Sie diesen Artikel durch. Möglicherweise finden Sie dies sehr nützlich:

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

Für den Fall, dass der obige Link eines Tages verschwindet, stelle ich das Hauptstück der folgenden Lösung fest:

Diese Lösung von Joseph M. Reagle über Daniel Starin:

Fügen Sie das Folgende zu Ihrem .bash_profile hinzu

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

Diese Version ist besonders schön, da sie anzeigt, ob Sie ssh-agent bereits gestartet haben. Wenn sie nicht gefunden wird, wird sie gestartet und die Einstellungen werden gespeichert, damit sie beim nächsten Start von a verwendet werden können Schale.

316
Litmus

Unter Arch Linux funktioniert Folgendes wirklich gut (sollte auf allen auf Systemdiensten basierenden Distributionen funktionieren):

Erstellen Sie einen systemd-Benutzerdienst, indem Sie ~/.config/systemd/user/ssh-agent.service:

[Unit]
Description=SSH key agent

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

[Install]
WantedBy=default.target

Richten Sie die Shell so ein, dass sie eine Umgebungsvariable für den Socket hat (.bash_profile, .zshrc, ...):

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

Aktivieren Sie den Dienst, damit er beim Anmelden automatisch gestartet wird, und starten Sie ihn:

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

Fügen Sie Ihrer SSH-Konfigurationsdatei die folgende Konfigurationseinstellung hinzu: ~/.ssh/config (funktioniert seit SSH 7.2):

AddKeysToAgent  yes

Dadurch wird der ssh-Client angewiesen, den Schlüssel immer einem ausgeführten Agenten hinzuzufügen, sodass er nicht vorher mit ssh hinzugefügt werden muss.

80
spheenik

Alte Frage, aber ich bin auf eine ähnliche Situation gestoßen. Denken Sie nicht, dass die obige Antwort das Notwendige vollständig erreicht. Das fehlende Stück ist keychain; Installieren Sie es, falls es noch nicht geschehen ist.

Sudo apt-get install keychain

Fügen Sie dann die folgende Zeile zu Ihrem ~/.bashrc

eval $(keychain --eval id_rsa)

Dies startet das ssh-agent Wenn es nicht läuft, stellen Sie eine Verbindung her, wenn dies der Fall ist, laden Sie das ssh-agent Umgebungsvariablen in Ihre Shell und laden Sie Ihren SSH-Schlüssel.

Veränderung id_rsa zu welchem ​​privaten Schlüssel in ~/.ssh Sie möchten laden.

Referenz

https://unix.stackexchange.com/questions/90853/how-can-i-run-ssh-add-automatically-without-password-Prompt

47
xelber

Die akzeptierte Lösung hat folgende Nachteile:

  • es ist kompliziert zu pflegen;
  • es wertet die Speicherdatei aus, was zu Fehlern oder Sicherheitsverletzungen führen kann.
  • es startet den Agenten, stoppt ihn aber nicht, was in etwa dem Zurücklassen des Schlüssels in der Zündung entspricht.

Wenn für Ihre Schlüssel keine Kennworteingabe erforderlich ist, empfehle ich die folgende Lösung. Fügen Sie Folgendes zu Ihrem .bash_profileganz am Ende (bearbeiten Sie die Schlüsselliste nach Ihren Wünschen) hinzu:

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

Es hat folgende Vorteile:

  • viel einfachere Lösung;
  • die Agentensitzung endet, wenn die Bash-Sitzung endet.

Es gibt mögliche Nachteile:

  • der interaktive Befehl ssh-add beeinflusst nur eine Sitzung, was in der Tat nur unter sehr untypischen Umständen ein Problem darstellt.
  • unbrauchbar, wenn die Eingabe eines Passworts erforderlich ist;
  • gestartet Shell wird nicht angemeldet (was keinen Einfluss auf AFAIK hat).

Beachten Sie, dass mehrere ssh-agent - Prozesse keinen Nachteil darstellen, da sie nicht mehr Arbeitsspeicher oder CPU-Zeit beanspruchen.

37
midenok

Fügen Sie dies zu Ihrem ~/.bashrc Hinzu, loggen Sie sich dann aus und wieder ein, um wirksam zu werden.

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

Dies sollte nur bei der ersten Anmeldung nach jedem Neustart zur Eingabe eines Kennworts auffordern. Es wird weiterhin dasselbe ssh-agent Verwendet, solange es ausgeführt wird.

21
Collin Anderson

Also habe ich die oben beschriebenen Ansätze verwendet, aber ich bevorzuge es, dass der Agent stirbt, wenn meine letzte Bash-Sitzung endet. Dies ist etwas länger als die anderen Lösungen, aber mein bevorzugter Ansatz. Die Grundidee ist, dass die erste Bash-Sitzung den ssh-agent startet. Dann sucht jede weitere Bash-Sitzung nach der Konfigurationsdatei (~/.ssh/.agent_env). Wenn dies der Fall ist und eine Sitzung ausgeführt wird, geben Sie einen Quellcode für die Umgebung ein und erstellen Sie einen Hardlink zur Socket-Datei in /tmp (muss sich auf demselben Dateisystem befinden wie die ursprüngliche Socket-Datei). Beim Beenden von Bash-Sitzungen wird für jede Sitzung ein eigener Hardlink gelöscht. Die letzte Sitzung, die geschlossen werden soll, stellt fest, dass die Hardlinks 2 Links haben (den Hardlink und das Original). Das Entfernen des eigenen Sockets und das Beenden des Prozesses führen zu 0 und hinterlassen eine saubere Umgebung, nachdem die letzte Bash-Sitzung geschlossen wurde.

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

Um noch eine weitere Lösung hinzuzufügen: P, ich habe mich für eine Kombination von @spheenik und @ collin-andersons Lösungen entschieden.

 # 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

Könnte ein wenig eleganter sein, aber es ist einfach und lesbar. Diese Lösung:

  • stellt sicher AddKeysToAgent yes befindet sich in Ihrer SSH-Konfiguration, sodass Schlüssel bei Verwendung automatisch hinzugefügt werden
  • fordert Sie bei der Anmeldung nicht zur Eingabe von Passwörtern auf (erneut erfolgt die einmalige Eingabe von Passwörtern bei der ersten Verwendung)
  • startet einen ssh-agent im stillen, falls er noch keinen gestartet hat

Kommentare willkommen :)

5
Keego

Ich habe es gelöst, indem ich es dem/etc/profile - system wide (oder dem lokalen .profile des Benutzers oder .bash_profile) hinzugefügt habe.

# 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

Dadurch wird ein neuer ssh-agent gestartet, wenn er nicht für den Benutzer ausgeführt wird, oder der Parameter ssh-agent env wird neu festgelegt, wenn er ausgeführt wird.

2
TheFrog

Entschuldigung für die Verspätung:

Benutzer der fish Shell können diese script verwenden, um dasselbe zu tun.

# 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
2
Daniel Gerber

Mag deine Antworten sehr. Es machte die Arbeit von cygwin / linux Hosts viel einfacher. Ich habe Start- und Endfunktionen kombiniert, um die Sicherheit zu gewährleisten.

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

danke noch einmal

1
Knelis