Wie kann ich ssh-add automatisch ohne Aufforderung zur Kennworteingabe ausführen?

Ich möchte über SSH zwischen mehreren Computern in meinem Netzwerk (statisches Ethernet) kommunizieren. Dazu muss ich jedes Mal, wenn ich mich auf einem bestimmten Computer anmelde, ssh-add ausführen. Wie kann ich dies tun, damit es einmal eingerichtet wird und mich nicht jedes Mal, wenn ich mich anmelde oder neu starte, nach der Passphrase fragt? meine Maschine?

Ich weiß, dass es eine Möglichkeit gibt, der bash_profileDatei einige Zeilen hinzuzufügen , aber ich muss das Kennwort jedes Mal eingeben, wenn ich mich bei einem bestimmten Computer neu starte / anmelde.

if [ -z "$SSH_AUTH_SOCK" ] ; then
    eval `ssh-agent -s`
    ssh-add
fi

Dies ist ein typisches Beispiel für einen Kompromiss zwischen Sicherheit und Komfort. Zum Glück gibt es eine Reihe von Möglichkeiten. Die am besten geeignete Lösung hängt vom Verwendungsszenario und der gewünschten Sicherheitsstufe ab.

SSH-Schlüssel mit Passwort, nein ssh-agent

Jetzt muss die Passphrase jedes Mal eingegeben werden, wenn der Schlüssel zur Authentifizierung verwendet wird. Dies ist vom Standpunkt der Sicherheit aus die beste Option, bietet jedoch die schlechteste Verwendbarkeit. Dies kann auch dazu führen, dass eine schwache Passphrase gewählt wird, um die Last der wiederholten Eingabe zu verringern.

ssh-key mit passphrase, mit ssh-agent

Wenn Sie Folgendes hinzufügen, ~/.bash_profilewerden ssh-agentdie SSH-Schlüssel beim Anmelden automatisch gestartet und geladen:

if [ -z "$SSH_AUTH_SOCK" ] ; then
  eval `ssh-agent -s`
  ssh-add
fi

Jetzt muss die Passphrase bei jedem Login eingegeben werden. Unter dem Gesichtspunkt der Benutzerfreundlichkeit ist dies zwar etwas besser, hat aber den Nachteil, dass Sie zur ssh-agentEingabe der Passphrase aufgefordert werden, unabhängig davon, ob der Schlüssel während der Anmeldesitzung verwendet werden soll oder nicht. Jedes neue Login erzeugt auch eine bestimmte ssh-agentInstanz, die mit den hinzugefügten Schlüsseln im Speicher auch nach dem Abmelden ausgeführt wird, sofern dies nicht ausdrücklich beendet wird.

Um ssh_agentbeim Abmelden abzubrechen, fügen Sie Folgendes zu hinzu~/.bash_logout

if [ -n "$SSH_AUTH_SOCK" ] ; then
  eval `/usr/bin/ssh-agent -k`
fi

oder folgendes an ~/.bash_profile

trap 'test -n "$SSH_AUTH_SOCK" && eval `/usr/bin/ssh-agent -k`' 0

Das Erstellen mehrerer ssh-agentInstanzen kann vermieden werden, indem an einem festen Speicherort im Dateisystem ein permanenter Kommunikationssocket für den Agenten erstellt wird, z. B. in der Antwort von Collin Anderson . Dies ist eine Verbesserung gegenüber dem Spawnen mehrerer Agenteninstanzen, sofern der entschlüsselte Schlüssel nach dem Abmelden nicht explizit beendet wird.

Auf Desktops können die in der Desktop-Umgebung enthaltenen ssh-Agenten wie der Gnome-Schlüsselring-SSH-Agent eine bessere Methode sein, da sie normalerweise die Passphrase abfragen, wenn der ssh-Schlüssel zum ersten Mal während einer Anmeldesitzung und verwendet wird Speichern Sie den entschlüsselten privaten Schlüssel bis zum Ende der Sitzung im Speicher.

ssh-key mit passphrase, mit ssh-ident

ssh-identist ein Dienstprogramm, das ssh-agentin Ihrem Namen verwaltet und Identitäten nach Bedarf lädt. Es werden nur einmal benötigte Schlüssel hinzugefügt, unabhängig von der Anzahl der Terminals, SSH- oder Anmeldesitzungen, für die ein Zugriff erforderlich ist ssh-agent. Es kann auch einen anderen Agenten und einen anderen Schlüsselsatz hinzufügen und verwenden, je nachdem, mit welchem ​​Host eine Verbindung hergestellt wird oder von welchem ​​Verzeichnis aus ssh aufgerufen wird. Dies ermöglicht das Isolieren von Schlüsseln, wenn die Agentenweiterleitung mit verschiedenen Hosts verwendet wird. Es ermöglicht auch die Verwendung mehrerer Konten auf Websites wie GitHub.

Um es zu aktivieren ssh-ident, installieren Sie es und fügen Sie den folgenden Alias ​​zu Ihrem hinzu ~/bash_profile:

alias ssh='/path/to/ssh-ident'

ssh-key mit passphrase, mit keychain

keychainist ein kleines Hilfsprogramm, das ssh-agentin Ihrem Auftrag verwaltet wird und das ssh-agentnach Beendigung der Anmeldesitzung weiterhin ausgeführt werden kann. Bei nachfolgenden Anmeldungen keychainwird eine Verbindung mit der vorhandenen ssh-agentInstanz hergestellt. In der Praxis bedeutet dies, dass die Passphrase erst bei der ersten Anmeldung nach einem Neustart eingegeben werden muss. Bei nachfolgenden Anmeldungen wird der unverschlüsselte Schlüssel der vorhandenen ssh-agentInstanz verwendet. Dies kann auch nützlich sein, um die kennwortlose RSA / DSA-Authentifizierung in cronJobs ohne kennwortlose SSH-Schlüssel zuzulassen .

Zum Aktivieren keychaininstallieren Sie es und fügen Folgendes hinzu ~/.bash_profile:

eval `keychain --agents ssh --eval id_rsa`

Aus sicherheitstechnischer Sicht ssh-identund keychainsind schlechter als ssh-agentInstanzen der Lebensdauer einer bestimmten Sitzung beschränkt, sondern sie bieten ein hohes Maß an Komfort. Um die Sicherheit von zu verbessern keychain, fügen einige Benutzer die --clearOption zu ihrem ~/.bash_profileSchlüsselbundaufruf hinzu. In diesem Fall müssen die Passphrasen beim Anmelden wie oben beschrieben erneut eingegeben werden. cronJobs haben jedoch nach dem Abmelden des Benutzers weiterhin Zugriff auf die unverschlüsselten Schlüssel. Die keychain Wiki-Seite enthält weitere Informationen und Beispiele.

ssh-key ohne passphrase

Aus Sicherheitsgründen ist dies die schlechteste Option, da der private Schlüssel für den Fall, dass er offengelegt wird, vollständig ungeschützt ist. Dies ist jedoch die einzige Möglichkeit, um sicherzustellen, dass die Passphrase nach einem Neustart nicht erneut eingegeben werden muss.

ssh-key mit passphrase, mit ssh-agent , passphrase ssh-add vom script übergeben

Es scheint zwar eine einfache Idee zu sein, die Passphrase ssh-addvon einem Skript aus zu übergeben, echo "passphrase\n" | ssh-adddies ist jedoch nicht so einfach, wie es scheint, da ssh-add die Passphrase nicht gelesen wird stdin, sondern /dev/ttydirekt zum Lesen geöffnet wird .

Dies kann umgangen mit expectfür die Automatisierung von interaktiven Anwendungen, ein Werkzeug. Unten sehen Sie ein Beispiel für ein Skript, das einen SSH-Schlüssel mithilfe einer im Skript gespeicherten Passphrase hinzufügt:

#!/usr/bin/expect -f
spawn ssh-add /home/user/.ssh/id_rsa
expect "Enter passphrase for /home/user/.ssh/id_rsa:"
send "passphrase\n";
expect "Identity added: /home/user/.ssh/id_rsa (/home/user/.ssh/id_rsa)"
interact

Beachten Sie, dass die Passphrase im Skript im Klartext gespeichert ist. Aus Sicht der Sicherheit ist dies kaum besser als ein passwortloser SSH-Schlüssel. Wenn dieser Ansatz verwendet werden soll, muss sichergestellt werden, dass für das expectSkript, das die Passphrase enthält, die richtigen Berechtigungen festgelegt sind, sodass es nur vom Schlüsseleigentümer gelesen, geschrieben und ausgeführt werden kann.

Fügen Sie dies zu Ihrem ~/.bashrcKonto hinzu und melden Sie sich dann ab und wieder an, damit es wirksam wird.

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 immer wieder verwendet, ssh-agentsolange es ausgeführt wird.

Nicht eng mit der Frage des OP verwandt, könnte aber für andere nützlich sein: Seit 7.2.0 verfügt ssh (1) über eine Option, die das Hinzufügen eines Schlüssels zum ssh-agent bei der ersten Authentifizierung ermöglicht; die Option ist AddKeysToAgentund eingestellt werden kann yes, no, ask, oder confirm, systemweite oder Ihre persönliche .ssh/configDatei.

Referenz: https://www.openssh.com/txt/release-7.2

ssh-agent speichert verschiedene nicht gesperrte SSH-Schlüssel im Cache, sodass Sie SSH-Schlüssel durch Kennwörter schützen können, ohne sie jedes Mal eingeben zu müssen.

Um entsperrte Schlüssel zwischenzuspeichern, müssen diese natürlich entsperrt werden. Zum Entsperren von Schlüsseln, die mit einer Passphrase gesperrt sind, müssen diese Passphrasen natürlich bekannt sein.

Jede Methode, die keine Autorisierung durch einen Menschen erfordert (z. B. "Passwort eingeben"), macht Ihr System nicht nur unsicher. es macht auch den gesamten Zweck des SSH-Agenten bedeutungslos.

Nach alledem können Sie einfach SSH-Schlüssel verwenden, die nicht kennwortgeschützt sind ( Enterdrücken Sie, wenn Sie während der Schlüsselgenerierung nach einem Kennwort gefragt werden). Da es kein Passwort gibt, ssh-agentmüssen Sie nicht nach einem fragen, um es (nicht) zwischenzuspeichern.

Hier ist eine Problemumgehung, um Ihre SSH-Passphrase zu automatisieren.

1. Erstellen Sie ein einzeiliges Skript, das Ihre Passphrase in der Standardausgabe ausgibt, z. B .:

    echo 'echo MY_SSH_PASSWORD' > ~/.print_ssh_password && chmod 700 ~/.print_ssh_password
   

   Wichtig: Stellen Sie sicher, dass Sie den führenden Bereich kopieren, um zu verhindern , dass Ihr Kennwort in Ihrem Verlauf gespeichert wird .

Und verwenden Sie eine der folgenden Methoden.

• Verwenden eines Standardeingabeansatzes:

  cat ~/.ssh/id_rsa | SSH_ASKPASS=~/.print_ssh_password ssh-add -
  

• oder Named-Pipe- Ansatz:

  1. Erstellen Sie eine Named Pipe (Sie können auch eine Prozessersetzung versuchen ):

     mkfifo --mode 0600 ~/.ssh_fifo
     

  2. Führen Sie dies ssh-addaus, indem Sie das für die Authentifizierung verwendete Programm angeben:

     cat ~/.ssh/id_rsa >~/.ssh_fifo | SSH_ASKPASS=~/.print_ssh_password ssh-add ~/.ssh_fifo
     

  Siehe: man ssh-addum mehr darüber zu lesen SSH_ASKPASS.

Ich werde nicht empfehlen, dass Sie ssh-add (das einen ssh-Agenten öffnen muss) bei der Anmeldung verwenden. Dies liegt daran, dass Sie nicht steuern können, wann der Abschnitt ssh-agent endet, und ein Sicherheitsrisiko verursachen können, wenn Sie die Schlüsseldateien nicht in einem Anmeldeabschnitt verwenden müssen.

Ich empfehle vielmehr, ein Skript zu schreiben, das die Unter-Shell eines SSH-Agenten mit allen automatisch hinzugefügten Schlüsseldateien öffnet und bei Bedarf aufgerufen wird, um SSH zu verwenden. Wenn Sie dies übernehmen könnten, lesen Sie weiter.

Sie hätten zwei Möglichkeiten:

1. Entfernen Sie alle Passphrasen für Ihre Schlüssel, die eine schwache Sicherheit aufweisen, wenn Ihre Schlüsseldateien gestohlen werden. (daher nicht zu empfehlen )

2. Verwenden Sie für Ihre Schlüssel dieselbe Passphrase. In diesem Fall müssen Sie ssh-add keyfile1 keyfile2 ...die Passphrase nur einmal pro Abschnitt eingeben.

In beiden Fällen können Sie die folgende Skriptdatei "ssh_keys_section.sh" schreiben:

#!/bin/bash
# This script run a ssh-agent on a sub-shell and automatically ssh-add all keyfiles at once.
# This agent ends when you type `exit` to close the sub-shell.
exec ssh-agent bash -c "ssh-add /path/to/keyfile1 /path/to/keyfile2 ...; exec bash"

Bemerkungen:

• Befehl zum Ändern oder Löschen der Passphrase: ssh-keygen -p -f keyfile
• Innerhalb der Sub-Shell können Sie sogar mehrere Terminals mit denselben entsperrten Schlüsseln teilen, indem Sie einen Befehl wie /path/to/yourterminal &(abhängig vom Betriebssystem) verwenden.

if [ ! -S ${HOME}/.ssh/ssh_auth_sock ]; then
  eval $(ssh-agent)
  ln -sf "${SSH_AUTH_SOCK}" ${HOME}/.ssh/ssh_auth_sock
fi
export SSH_AUTH_SOCK=${HOME}/.ssh/ssh_auth_sock

ssh_keys=$(find -E ~/.ssh -type f -regex '.*(rsa$|pem)')
ssh_agent_keys=$(ssh-add -l | awk '{key=NF-1; print $key}')

for k in "${ssh_keys}"; do
    for l in "${ssh_agent_keys}"; do
        if [[ ! "${k}" = "${l}" ]]; then
            ssh-add "${k}" > /dev/null 2>&1
        fi
    done
done

Früher habe ich das von steampowered erwähnte Skript verwendet, jetzt habe ich das folgende Skript erstellt, da keine Dateien herumliegen.

zshNur an der Shell arbeiten.

#!/bin/sh

AGENT_BIN=`which ssh-agent`
AGENT_ADD_BIN=`which ssh-add`
AGENT_PID=`ps -fe | grep ${AGENT_BIN} | awk -vuser=$USER -vcmd="$AGENT_BIN" '$1==user && $8==cmd{print $2;exit;}'`
if [ -z "$AGENT_BIN" ]; then
    echo "no ssh agent found!";
    return
fi
if [ "" -eq "$AGENT_PID" ]; then
    if read -sq "YN?Do you want to unlock your ssh keys?"; then
        echo ""
        output=`$AGENT_BIN | sed 's/echo/#echo/g'`
        eval $output
        $AGENT_ADD_BIN
    fi
else
    for f in "/proc/"*
    do
        cmdline=`cat "$f/cmdline"`
        if [ "${AGENT_BIN}" -ef "${cmdline}" ]; then
            export SSH_AUTH_SOCK=`cat $f/net/unix | grep --binary-file=text -oP '((/[^/]*?)+/ssh-[^/]+/agent\.\d+$)'`
            export SSH_AGENT_PID=${f##*/}
            break;
        fi
    done
fi

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

Geben Sie hier Ihre Gutschrift ab: https://www.cygwin.com/ml/cygwin/2001-06/msg00537.html

Diese Lösung wird auch hier unterstützt: http://mah.everybody.org/docs/ssh

Single Sign On-Lösung für SSH könnte mich dazu führen pam_ssh.

Nach diesem Artikel lautet das Konzept:

Wenn Sie mit mehreren * nix-basierten Maschinen über ssh arbeiten, haben Sie es wahrscheinlich satt, ständig Ihr Kennwort eingeben zu müssen, wenn Sie auf eine andere Box zugreifen möchten. Es gibt eine sichere Methode, mit der Sie auf jeden Computer zugreifen können, auf den Sie SSH-Zugriff haben, ohne ein anderes Kennwort eingeben zu müssen (außer dem, mit dem Sie sich ursprünglich angemeldet haben).

Dies ist eigentlich ganz einfach zu bewerkstelligen. Sie erstellen lediglich ein öffentliches / privates Schlüsselpaar, um sich bei Ihren anderen Rechnern zu authentifizieren, und lassen dann von PAM einen Agenten starten, der Ihre Schlüssel nach der Anmeldung lädt. Auf diese Weise erhalten Sie eine Single Signon-Lösung für den Zugriff auf Ihre gesamte Fernbedienung maschinen. Dieser Leitfaden führt Sie durch die Einrichtung.

Ich habe nicht überprüft, dass dies tatsächlich funktionieren würde.

Fügen Sie dies zu Ihrer ~/.bashrcDatei hinzu:

ssh-add -L|grep identities > /dev/null && ssh-add /path/to/ssh/private/key

Um einen (möglicherweise kennwortlosen) Schlüssel hinzuzufügen und sicherzustellen, dass Sie ssh-addnicht zur Eingabe eines Kennworts aufgefordert werden, auch wenn Sie unter X ausgeführt werden :

DISPLAY= ssh-add -k /path/to/key </dev/null &>/dev/null

Der Beendigungsstatus zeigt Erfolg oder Misserfolg an.

Wenn Sie Seepferdchen als Ihr Passwort-Manager verwenden ... Was Sie wahrscheinlich sind; D

Eine andere Lösung, die das gesuchte Ziel erreicht, besteht darin, die SSH-Schlüssel zu seahorse hinzuzufügen, um sie beim Anmelden automatisch zu entsperren. Der Hauptvorteil dabei ist, dass Sie nach der Anmeldung über gdm oder mit was auch immer Sie sich anmelden, niemals ein Kennwort für die Schlüssel eingeben müssen, selbst wenn die Schlüssel ein Kennwort haben. Dies erfordert sowohl den privaten als auch den öffentlichen Schlüssel. Sie MÜSSEN auch eine Namenskonvention für Seepferdchen befolgen. Die Standardeinstellung ist akzeptabel (id_rsa für privaten Schlüssel und id_rsa.pub für öffentlichen Schlüssel ... Eigentlich alles, was privatekeyname und privatekeyname.pub ist ).

Hinzufügen Ihres SSH-Schlüssels zu Seahorse zum automatischen Entsperren bei der Anmeldung; (Auf fedora25 bin ich mir nicht sicher, wo sich der Pfad auf anderen Distributionen befindet, obwohl er höchstwahrscheinlich sehr ähnlich ist.)

/lib64/seahorse/seahorse-ssh-askpass /path/to/keys/here

Für mich war es das

/lib64/seahorse/seahorse-ssh-askpass ~/.ssh/id_rsa

(seahorse geht automatisch davon aus, dass der öffentliche Schlüssel in meinem Fall id_rsa.pub war.)

Nachdem der Befehl ausgeführt wurde, öffnet seahorse ein kleines gtk-Passwortfeld, in das Sie das Passwort für den privaten Schlüssel eingeben können. oder lassen Sie es einfach leer, wenn Sie den Schlüssel ohne Passwort generiert haben.

Seahorse fordert Sie nicht auf, wenn alles in Ordnung ist. Sie müssen versuchen, ssh auf den Zielcomputer zu übertragen. Dann werden Sie von seahorse aufgefordert, den Schlüssel mit einem Kennwort grafisch zu entsperren (DAS PASSIERT NUR EINMAL), aber diesmal sollte es ein wenig anders aussehen ), und bieten Sie die OPTION an, den Schlüssel beim Anmelden zu entsperren. Aktivieren Sie diese Option, um Ihr Ziel zu erreichen.

Nur weil ich nicht alle Antworten gelesen habe, würde ich empfehlen, rückgängig zu machen, was alle Ihnen mit ssh-add gesagt haben, bevor Sie diese Antwort versuchen. Andernfalls kann es passieren, dass Ihren Schlüsseln etwas Schlimmes passiert, idk.

Hier ist das endgültige Drehbuch.

Aktualisieren Sie $ PASSW und kopieren Sie es in Ihr Terminal

# <sshpass> via typinator
# Updated: 2017-01-18_21h36
#
# apt-get update -y; apt-get install expect -qy

# Pass this value to ssh-add
PASSW="myfancypass123"

# Define a name for this script
THIS_SCRIPT="$(date +%Y-%m-%d_%H-%M-%S-%N)".sh

# Create a fresh directory to work from / Clean up
rm -rf ~/temp; mkdir -p ~/temp; cd ~/temp; ls -la


# Output our bash script file - BEGIN
cat <<< '
#!/bin/bash

set -u     # Stop if an unbound variable is referenced
set -e     # Stop on first error
export HISTIGNORE="expect*";

# Normal CMDs
echo && echo "The process should take about 10 seconds:" && echo
eval "$(ssh-agent -s)"; sleep 0.5;

# Define VAR passed when this bash-script was launched
password="$@"

# Launch the expect magic
expect -c "
    spawn ssh-add /root/.ssh/id_rsa
    expect "?assword:"
    send \"$password\r\"
    expect "?password:"
    send \"$password\r\"
    expect eof"

export HISTIGNORE="";
export password="";
' > $THIS_SCRIPT
# Output our bash script file - END


# Ensure we are in the right path
cd ~/temp; ls -la; sleep 1;

# Run the bash script
chmod +x ./$THIS_SCRIPT; ./$THIS_SCRIPT "$PASSW"; unset password;

# Clean up
rm -rf ~/temp; mkdir -p ~/temp; cd ~/temp; ls -la

Die beste Methode, die mir bekannt ist, ist die Verwendung eines PAM-Anmeldeskripts, das ich aus früheren Arbeiten übernommen habe, da ich in dieser Frage keine zufriedenstellende Antwort gefunden habe.

Ihre Passphrase wird verschlüsselt mit Ihrem Systemkennwort und einer umfangreichen Ableitungsfunktion gespeichert. Bei der Anmeldung wird Ihr Systemkennwort zum Entschlüsseln Ihrer Passphrase und zum Hinzufügen zum Agenten verwendet.

https://github.com/capocasa/systemd-user-pam-ssh

Der Vorteil gegenüber jeder anderen vorgestellten Lösung besteht darin, dass sie die Sicherheit kombiniert, die dem manuellen Ausführen von ssh-add beim Booten ohne Aufwand entspricht. Es sind keine zusätzlichen Tools erforderlich und eine zusätzliche Abhängigkeit ist auf den meisten Systemen (OpenSSL) bereits standardmäßig installiert.

Mein Setup unter macOS ist wie folgt (in .zshrcoder .bash_profilefür Bash-Leute):

# Kill then Load the ssh-agent and set the necessary env variables it outputs
sshRestart() {
    # if all else fails
    # pkill -u $(whoami) ssh-agent;

    if [ -n "$SSH_AUTH_SOCK" ] ; then
        eval `/usr/bin/ssh-agent -k`
    fi
    eval `ssh-agent -s`
    ssh-add ~/.ssh/YOUR_KEY_FILE
    echo "Restarted SSH agent"
}

if [ -z "$SSH_AUTH_SOCK" ] || [[ $SSH_AUTH_SOCK == *"/private/tmp/"* ]] ; then
    eval `ssh-agent -s` > /dev/null 2>&1
    ssh-add ~/.ssh/YOUR_KEY_FILE > /dev/null 2>&1
fi

Das || [[ $SSH_AUTH_SOCK == *"/private/tmp/"* ]]Teil ist unter macOS erforderlich, da der Standardwert ist /private/tmp/com.apple.launchd.SOMETHINGHERE/Listeners. Andernfalls schlägt die umfassende Antwort von @Thomas Nyman fehl, da $SSH_AUTH_SOCKimmer etwas eingestellt ist.

Dann in .zlogout(oder .bash_logoutfür bash Leute):

if [ -n "$SSH_AUTH_SOCK" ] ; then
    eval `/usr/bin/ssh-agent -k`
fi

Getestet unter macOS Mojave 10.14.5