Hogyan futtathatom az ssh-add funkciót automatikusan, jelszó nélkül?

Ez egy tipikus példa az értékpapírok közötti kompromisszumra és kényelem. Szerencsére számos lehetőség van. A legmegfelelőbb megoldás a használati forgatókönyvtől és a kívánt biztonsági szinttől függ.

ssh-kulcs jelszóval, nem ssh-agent

Most minden alkalommal be kell írni a jelszót, amikor a kulcsot hitelesítésre használják. Bár ez biztonsági szempontból a legjobb megoldás, a legrosszabb használhatóságot kínálja. Ez azt is eredményezheti, hogy egy gyenge jelszót sorrendben választanak, ezzel csökkentve az ismételt megadásának terheit.

ssh-kulcs jelszóval, ssh-agent

A következők hozzáadása a ~/.bash_profile fájlhoz automatikusan elindul ssh-agent és töltse be az ssh-kulcs (oka) t a bejelentkezéskor:

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

Mostantól a jelszót meg kell adni Belépés. Bár használhatóság szempontjából valamivel jobb, ennek megvan az a hátránya, hogy a ssh-agent a jelszót kéri, függetlenül attól, hogy a kulcsot használni akarják-e a bejelentkezési munkamenet során. Minden új bejelentkezés egy különálló ssh-agent példányt is létrehoz, amely a memóriában lévő hozzáadott kulcsokkal a kijelentkezés után is fut, kivéve, ha kifejezetten megölik.

A ssh_agent kijelentkezéskor adja hozzá a következőket a ~/.bash_logout

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

vagy a következőkhöz: ~/.bash_profile

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

Több ssh-agent példány létrehozása elkerülhető tartós kommunikációs socket létrehozása az ügynökhöz a fájlrendszer egy rögzített helyén, például Collin Anderson válaszában . Ez előrelépés több ügynök ívásával szemben. Például, kivéve, ha kifejezetten megölték, a visszafejtett kulcs továbbra is a memóriában marad a kijelentkezés után.

Asztali számítógépeken az asztali környezethez tartozó ssh-ügynökök, például a Gnome kulcstartó SSH ügynök , jobb megközelítés lehet, mivel általában az átadásra kérhetnek kifejezés az első alkalommal, amikor az ssh-kulcsot egy bejelentkezési munkamenet során használják, és tárolja a visszafejtett titkos kulcsot a memóriában a munkamenet végéig.

ssh- kulcs jelszóval, ssh-ident

ssh-ident olyan segédprogram, amely az Ön nevében kezelheti a ssh-agent t, és szükség esetén be tudja tölteni az identitásokat. A kulcsokat csak egyszer adja hozzá, ha szükséges, függetlenül attól, hogy hány terminál, ssh vagy bejelentkezési munkamenet igényel hozzáférést egy ssh-agent fájlhoz. Hozzáadhat és használhat egy másik ügynököt és más kulcskészletet is, attól függően, hogy a gazdagéphez csatlakozik-e, vagy az ssh könyvtárat hívják meg. Ez lehetővé teszi a kulcsok elkülönítését, ha az ügynököt továbbítja különböző gazdagépekkel. Ez lehetővé teszi több fiók használatát olyan webhelyeken is, mint a GitHub.

A ssh-ident engedélyezéséhez telepítse és adja hozzá a következő álnevet a :

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

ssh-kulcs jelszóval, keychain

keychain egy kisméretű segédprogram, amely a ssh-agent t kezeli az Ön nevében, és lehetővé teszi a ssh-agent működését a bejelentkezési munkamenet végén. A következő bejelentkezéskor a keychain csatlakozni fog a meglévő ssh-agent példányhoz. A gyakorlatban ez azt jelenti, hogy a jelszót csak az újraindítást követő első bejelentkezéskor kell megadni. A következő bejelentkezéskor a meglévő ssh-agent példány titkosítatlan kulcsát használják.Ez akkor is hasznos lehet, ha jelszó nélküli RSA / DSA hitelesítést engedélyeznek cron feladatokban jelszó nélküli ssh-kulcsok nélkül.

A keychain, telepítse és adjon hozzá valami hasonlót a következőhöz: ~/.bash_profile:

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

nézetben a ssh-ident és a keychain rosszabb, mint a ssh-agent példányok, amelyek csak egy adott életre korlátozódnak munkamenetet, de magas szintű kényelmet kínálnak. A keychain biztonságának javítása érdekében egyesek hozzáadják a --clear beállítást a ~/.bash_profile kulcstartójukhoz. behívás. Ezzel a jelszavakat újra be kell írni a bejelentkezéskor, a fentiek szerint, de a cron feladatok a felhasználó kijelentkezése után is hozzáférhetnek a titkosítatlan kulcsokhoz. A keychain wiki oldalon további információk és példák találhatók.

ssh-kulcs jelmondat nélkül

Biztonsági szempontból ez a legrosszabb lehetőség, mivel a titkos kulcs teljesen védtelen abban az esetben, ha ki van téve. Ez az egyetlen módja annak biztosítására, hogy a jelszót ne kelljen újra beírni az újraindítás után.

ssh-kulcs jelszóval, a ssh-agent, jelszó átadása a ssh-add a

szkriptből egyértelmű ötletnek tűnik, hogy a jelszót átadja egy szkriptből a ssh-add -nek, pl. echo "passphrase\n" | ssh-add, ez nem olyan egyszerű, mint amilyennek látszik, mint ssh-add nem olvassa el a jelmondat a (z) stdin címről, de a /dev/tty fájlt közvetlenül megnyitja .

Ez lehet megkerült az expect , az interaktív automatizálás eszközével alkalmazások. Az alábbiakban bemutatunk egy példát egy szkriptre, amely hozzáad egy ssh-kulcsot a szkriptben tárolt jelszó használatával:

#!/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 

Ne feledje, hogy mivel a jelszó sima szövegben van tárolva a a szkript biztonsági szempontból aligha jobb, mint egy jelszó nélküli ssh-kulcs. Ha ezt a megközelítést akarjuk használni, akkor fontos megbizonyosodni arról, hogy a jelszót tartalmazó expect szkript megfelelő engedélyekkel rendelkezik-e, így olvashatóvá, írhatóvá és csak a kulccsal futtathatóvá tulajdonos.

Megjegyzések

• Rendben, de amikor a ~ / .bash_profile fájlba helyezem a kódot, minden bejelentkezéskor be kell írnom a jelszót, ne akarja ezt sem ‘. Egyáltalán nem érdekel a biztonság. echo ” passz \ n ” | Az ssh-add nem működik ‘ t
• @ user1607072 Igen, a ssh-agent kódrészlet a ~/.bash_profile a válaszban leírtak szerint viselkedik. Érdemes megnéznie a keychain segédprogramot. A keychain használatával az újraindítás után az első bejelentkezéskor meg kell adnia a jelszót, de a következő bejelentkezésekor a keychain egy meglévő ssh-agent példány a visszafejtett kulccsal a memóriában. Ettől eltekintve ‘ s lehetősége van ssh-kulcs előállítására jelszó nélkül, de ez természetesen nem ajánlott.
• @ user1607072 Bár erősen szeretném Javasoljuk az egyik biztonságosabb megközelítést, van mód arra, hogy a jelszót átadja egy szkriptből a ssh-add -nek. A (z) echo "pass\n" | ssh-add oka nem az, hogy a ssh-add nem olvassa be a jelszót a következőből: stdin, de a /dev/tty fájlt közvetlenül megnyitja olvasásra. A expect elnevezésű segédprogram segítségével frissítette a választ, hogy megkerülje ezt.
• @ user1607072 Lehet, hogy kissé túlterheli a felhasználási esetet, de Kerberos az ssh GSSAPI támogatással kombinálva, jelszó nélküli ssh bejelentkezéshez is használható. Az ssh megfelelő hitelesítési módszerét gssapi-with-mic néven hívják. Ezt általában nagyobb hálózatokban használják, de természetesen, ha érdekel ez iránt, érdemes lehet megvizsgálni.
• @ErickBrown: Már válaszolt itt . Az SSH Agent egységet a kijelentkezéskor le kell állítani, ha a systemd bejelentkezés kezelőjében le van tiltva a felhasználók elhúzódása. Ha a felhasználói elhúzódás engedélyezve van, a systemd felhasználói példány és az SSH Agent egység az utolsó bejelentkezési munkamenet lezárása után is futni fog.

Adja hozzá a ~/.bashrc fiókjához, majd jelentkezzen ki és lépjen vissza, hogy életbe lépjen.

 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  

Ezzel csak jelszót kell kérnie az első alkalommal minden újraindítás után bejelentkezik. Addig fogja használni ugyanazt a ssh-agent -et, amíg fut.

Megjegyzések

• nagyon ügyes , így csak egy ssh-ügynök fut (: Több ügynök, mint @thomasNyman ‘ második megoldásában biztonsági kockázatnak tűnik számomra …
• Különböző helyszíneken végzett kutatások és különféle megoldások elolvasása után úgy tűnik, hogy ez a legvilágosabb, egyenesen a lényegre mutat. Nagyon szép. +1
• jobb erre: `alias ssh = ssh-check-agent “, és a check-agent verziót hajtsa végre a fentiekkel. Így: a) csak egy ügynököt kap, és b) csak akkor kapja meg az ügynököt, ha szüksége van rá
• Szerintem a -s az alapértelmezett, ezért ‘ ezt már megtesszük.
• Ne feledje, hogy ssh-add argumentumok nélkül hozzáadja a ~/.ssh/id_rsa szót. Érdemes átadni ssh-add argumentumokat, ha a magánkulcsai egy másik fájlban vannak.

ssh-agent gyorsítótárba helyezi a különféle fel nem oldott ssh-kulcsokat, így az ssh-kulcsokat jelszavakkal védheti, anélkül azonban, hogy minden egyes alkalommal be kellene írnia őket. A zárolt kulcsok gyorsítótárba helyezéséhez nyilvánvalóan fel kell oldania ezeket a kulcsokat. A jelszóval lezárt kulcsok feloldásához nyilvánvalóan ismernie kell ezeket a jelszavakat.

Bármely módszer, amelyhez nincs szükség emberi engedélyre (pl. “Jelszó beírása”), nem csak a a rendszer bizonytalan; értelmetlenné teszi az ssh-agent teljes célját is.

Mindezek után egyszerűen használhatja a jelszóval nem védett ssh-kulcsokat (nyomja meg az Enter parancsot jelszóhoz a kulcsgenerálás során). Mivel nincs “t” jelszó, a ssh-agent nem kell kérnie tőled, hogy (ne) gyorsítótárazza.

Megjegyzések

• Egyetértek azzal, hogy amíg a kulcsaidat csak a felhasználók engedélyezik, az ssh-agentnek kevés előnye van az engedély nélküli kulcsokkal szemben. szeretek belépni egy bejelentkezési kiszolgálóba, majd a szervernek van egy csomó permssionless kulcsa, amelyek mindegyike csak egy másik szerver feloldására használható. a bejelentkezési szerver nem csinál mást, ezért ‘ sokkal nehezebb feltörni / hamisítani stb. … a többi szervernek nincs jelszóhozzáférése, csak kulcsosak.

Itt van egy megoldás az SSH-jelszó automatizálásához.

1. Hozzon létre egy egyvonalas szkriptet, amely kinyomtatja a jelszót a standard kimenetre, például:

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

   Fontos: Győződjön meg róla, hogy átmásolja a vezető helyet a következő helyre: megakadályozza a jelszó tárolását az előzményekbe .

És használja az alábbi módszerek egyikét.

• szabványos bemeneti megközelítés használatával:

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

• vagy csövű megközelítés:

  1. Hozzon létre egy pipe (kipróbálhat egy folyamathelyettesítést is ):

     mkfifo --mode 0600 ~/.ssh_fifo 

  2. Futtassa ssh-add a hitelesítéshez használt program megadásával:

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

  Lásd: man ssh-add , ha többet szeretne megtudni a SSH_ASKPASS -ről.

Megjegyzések

• A echo my_passphrase nagy biztonsági rés. Először a beírása után a jelszó tiszta szöveggel szerepel annak a héjnak az előzményfájljában, amelyet használ. A második parancssori argumentumok pedig világszerte olvashatók a Unixon (ps -ef). Soha ne írja be a jelszavakat parancssori argumentumokba!
• @ceving Extra vezető szóköz hozzáadása megoldja az előzményfájl problémáját. További információk hozzáadva.
• @kenorb: Ez nem ‘ nem oldja meg a ps alatt látható jelszó nagyobb problémáját. Kimenet. Az előzményfájl egyébként csak a tulajdonos felhasználó által olvasható, de a parancssorokat a rendszer minden felhasználója olvashatja.

Nem ajánlom az ssh-add-ot (aminek meg kell nyitnia az ssh-agentet) a bejelentkezéskor. Ez azért van, mert nem tudja ellenőrizni, hogy mikor zárul le az ssh-agent szakasz, és biztonsági kockázatot jelenthet. amikor nem kell a kulcsfájlokat egy bejelentkezési szakaszban használnia. szükséges az ssh használatához. Ha elfogadnád, olvass tovább.

Két lehetőséged lenne:

1. Távolítsd el a kulcsok összes jelszavát, amelyek gyenge biztonság , ha a kulcsfájljait ellopják. (Ezért nem ajánlott )

2. Használja ugyanazt a jelszót a kulcsainál. Ezután, amikor ssh-add keyfile1 keyfile2 ..., akkor csak egyszer kell beírnia a jelszót szakaszonként.

Mindkét esetben az alábbiak szerint írhat ilyen szkriptfájlt: “ssh_keys_section.sh”:

#!/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" 

Megjegyzések:

• Parancs a jelszó megváltoztatására vagy törlésére: ssh-keygen -p -f keyfile
• Az alhéjban még további terminálokat is elágazhat, amelyek ugyanazt használják feloldott kulcsok, esetleg egy olyan parancs használatával, mint /path/to/yourterminal & (az operációs rendszertől függ)

Megjegyzések

• Pl A Cygwin rendszeren belüli Windows rendszeren /path/to/yourterminal & == > mintty &
• Megjegyzés: használat után zárja le a munkamenetet ctrl-d vagy exit címmel, akárcsak egy beágyazott bash shell, és le kell zárni.

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 

Régebben a steampowered által említett szkriptet használtam, az alábbit most készítettem, mert nem hagy fájlokat fekve.

Csak a zsh héjon dolgozik.

#!/usr/bin/env zsh 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 

Megjegyzések

• ” Munka ezen csak a zsh shell “, oké, de miért állítja be a shebang-vonalad, hogy csak ” sh “?

Ha csikóhalat használ jelszókezelőként … Valószínűleg te vagy az; D

Egy másik megoldás, amellyel elérheted a keresett célt, egyszerűen hozzáadod az ssh kulcsokat a seahorse-hoz az automatikus feloldáshoz bejelentkezéskor . Ennek legfőbb előnye, hogy soha nem kell megadnia jelszót a kulcsokhoz, miután bejelentkezett a gdm-en keresztül, vagy bármi mással is bejelentkezett, még akkor is, ha a kulcsoknak van jelszava. Ehhez mind a magánkulcs, mind a nyilvános kulcs SZÜKSÉGES. A csikóhalak elnevezési megállapodásait is követniük kell. Az alapértelmezett érték elfogadható (az id_rsa a magánkulcshoz és az id_rsa.pub a nyilvános kulcshoz … Valójában bármi, ami privatekeyname és privatekeyname.pub )

Ssh kulcs hozzáadása a csikóhalhoz az automatikus feloldáshoz bejelentkezéskor; (A fedora25-nél nem vagyok biztos benne, hogy hol található az út a többi disztribúción, bár valószínűleg nagyon hasonló)

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

Számomra

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

(a csikó automatikusan feltételezi, hogy az én esetemben a nyilvános kulcs id_rsa.pub volt)

A parancs végrehajtása után a csikó lenyílik egy aranyos kis gtk jelszó mező a privát kulcs jelszavának beírásához, vagy egyszerűen hagyja üresen, ha a kulcsot jelszó nélkül generálta.

A Seahorse nem kéri, ha minden rendben van. Meg kell próbálnia ssh-t beírni a célgépbe.Ezután a csikóhalak kéri, hogy grafikusan nyissa ki a kulcsot egy jelszóval (EZ CSAK EGYSZER TÖRTÉNIK), de ezúttal kissé másképp kell kinéznie; P (ez az a rész is, ahol a csikóhal némi csikóhalat tesz az ssh-varázslathoz ), és felajánlja az OPTION lehetőséget a kulcs feloldásához bejelentkezéskor, be kell jelölnie ezt a lehetőséget érje el a célját.

Csak azért, mert nem olvastam el az összes választ, azt javasolnám, hogy a válasz megkísérlése előtt vonja vissza azt, amit mindenki mondott az ssh-add használatával. Ha másként cselekszik, akkor valami rossz történhet. a kulcsokhoz, idk.

Az SSH egyszeri bejelentkezési megoldása a pam_ssh .

A cikk szerint , a koncepció:

Ha több * nix-alapú géppel dolgozol az ssh-n keresztül, akkor valószínűleg unod a hátrányokat mindig be kell írnia a jelszavát, amikor egy másik mezőhöz szeretne hozzáférni. Van egy biztonságos módja annak, hogy minden olyan géphez hozzáférhessen, amelyhez ssh hozzáférése van, anélkül, hogy más jelszót kellene megadnia (az eredetileg bejelentkezettől eltérő).

Ez valójában meglehetősen egyszerű: alapvetően csak létre kell hozni egy nyilvános / privát kulcspárt, hogy hitelesítsd magad a többi gépeden, majd A PAM hozzon létre egy ügynököt, amely a bejelentkezés után betölti a kulcsokat, és egyetlen bejelentkezési megoldást kínál az összes távoli gép eléréséhez. Ez az útmutató végigvezeti Önt a beállításon.

Nem igazoltam, hogy ez valóban működne.

Ezt adja hozzá a ~/.bashrc fájljához:

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

Megjegyzések

• Nem tudom ‘ nem látom, hogy ez hogyan kapcsolódik a kérdéshez, amely arról szól, hogy nem kérik meg a jelszót a későbbi bejelentkezéskor.

Egy (esetleg jelszó nélküli) kulcs hozzáadása és a ssh-add nem kér jelszót, nem számít, még akkor is, ha X alatt fut:

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

A kilépés állapota sikert vagy sikertelenséget jelez.

Itt van a végleges forgatókönyv.

Frissítse a $ PASSW fájlt, majd másolja be és illessze be a terminálba

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

Saját A MacOS-on a következő a beállítás (.zshrc vagy .bash_profile a bash embereknél):

A || [[ $SSH_AUTH_SOCK == *"/private/tmp/"* ]] részre szükség van a macOS rendszeren, mert az alapértelmezett érték /private/tmp/com.apple.launchd.SOMETHINGHERE/Listeners. Ellenkező esetben a @Thomas Nyman átfogó válasz sikertelen, mert a $SSH_AUTH_SOCK mindig valamire van állítva.

Ezután a .zlogout (vagy .bash_logout bash embereknek):

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

MacOS Mojave 10.14.5 tesztelt

Ezt a GitHub nagyon jól megmagyarázta a ssh-agent automatikus indításakor a Git for Windows rendszerben , ami viszont a Linux alatt is működik.

A ssh-agent futtatható automatikusan, amikor megnyitja a bash vagy a Git héjat. Másolja a következő sorokat, és illessze be a ~/.profile vagy ~/.bashrc fájlba a Git shellben:

 env=~/.ssh/agent.env agent_load_env () { test -f "$env" && . "$env" >| /dev/null ; } agent_start () { (umask 077; ssh-agent >| "$env") . "$env" >| /dev/null ; } agent_load_env # agent_run_state: 0=agent running w/ key; 1=agent w/o key; 2= agent not running agent_run_state=$(ssh-add -l >| /dev/null 2>&1; echo $?) if [ ! "$SSH_AUTH_SOCK" ] || [ $agent_run_state = 2 ]; then agent_start ssh-add elif [ "$SSH_AUTH_SOCK" ] && [ $agent_run_state = 1 ]; then ssh-add fi unset env  

Ha a titkos kulcsa nincs az egyik alapértelmezett helyen tárolva (például ~/.ssh/id_rsa), meg kell mondania az SSH hitelesítő ügynöknek, hogy hol találja meg. A kulcs hozzáadásához az ssh-agenthez írja be a következőt: ssh-add ~/path/to/my_key.

Tipp: Ha azt akarja, hogy ssh-agent egy idő után elfelejtse a kulcsát, akkor állítsa be erre a ssh-add -t <seconds> futtatásával.