Jak mogę uruchomić ssh-add automatycznie, bez pytania o hasło?

Chcę komunikować się między kilkoma komputerami w mojej sieci (statyczny Ethernet) za pośrednictwem SSH. Aby to zrobić, muszę uruchamiać ssh-add za każdym razem, gdy loguję się na konkretnej maszynie, jak mogę to zrobić, aby została skonfigurowana raz i nie pytała mnie o hasło przy każdym logowaniu lub ponownym uruchomieniu moja maszyna?

Wiem, że istnieje sposób, aby dodać kilka wierszy do bash_profilepliku, ale nadal muszę wpisywać hasło przy każdym ponownym uruchomieniu / zalogowaniu się na konkretnej maszynie.

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

Jest to typowy przykład kompromisu między bezpieczeństwem a wygodą. Na szczęście istnieje wiele opcji. Najbardziej odpowiednie rozwiązanie zależy od scenariusza użytkowania i pożądanego poziomu bezpieczeństwa.

klucz ssh z hasłem, nie ssh-agent

Teraz hasło należy wprowadzić za każdym razem, gdy klucz jest używany do uwierzytelnienia. Chociaż jest to najlepsza opcja z punktu widzenia bezpieczeństwa, oferuje najgorszą użyteczność. Może to również prowadzić do wybierania słabego hasła w celu zmniejszenia obciążenia wielokrotnym wprowadzaniem go.

ssh-key z hasłem, z ssh-agent

Dodanie następującego polecenia ~/.bash_profilespowoduje automatyczne uruchomienie ssh-agenti załadowanie kluczy ssh podczas logowania:

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

Teraz hasło należy wprowadzić przy każdym logowaniu. Chociaż jest to nieco lepsze z punktu widzenia użyteczności, ma tę wadę, że ssh-agentmonituje o hasło, niezależnie od tego, czy klucz ma zostać użyty, czy nie podczas sesji logowania. Każde nowe logowanie powoduje także pojawienie się odrębnej ssh-agentinstancji, która pozostaje uruchomiona z dodanymi kluczami w pamięci nawet po wylogowaniu, chyba że zostanie wyraźnie zabita.

Aby zabić ssh_agentprzy wylogowaniu, dodaj następujące elementy do~/.bash_logout

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

lub następujące do ~/.bash_profile

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

Utworzenia wielu ssh-agentinstancji można uniknąć, tworząc trwałe gniazdo komunikacyjne z agentem w stałej lokalizacji w systemie plików, na przykład w odpowiedzi Collina Andersona . Jest to poprawa w stosunku do odradzania wielu instancji agentów, chyba że jawnie zabity odszyfrowany klucz nadal pozostaje w pamięci po wylogowaniu.

Na komputerach agenci ssh wchodzący w skład środowiska pulpitu, tacy jak agent SSH Gnome Keyring , mogą być lepszym podejściem, ponieważ zazwyczaj można je poprosić o podanie hasła przy pierwszym użyciu klucza ssh podczas sesji logowania i przechowuj odszyfrowany klucz prywatny w pamięci do końca sesji.

ssh-key z hasłem, z ssh-ident

ssh-identto narzędzie, które może zarządzać ssh-agentw Twoim imieniu i ładować tożsamości w razie potrzeby. Dodaje klucze tylko raz, gdy są potrzebne, niezależnie od liczby terminali, sesji ssh lub logowania, które wymagają dostępu do ssh-agent. Może także dodawać i używać innego agenta i innego zestawu kluczy w zależności od podłączonego hosta lub katalogu, z którego ssh jest wywoływany. Umożliwia to izolowanie kluczy podczas korzystania z przekazywania agenta na różnych hostach. Pozwala także na korzystanie z wielu kont w witrynach takich jak GitHub.

Aby włączyć ssh-ident, zainstaluj i dodaj następujący alias do ~/bash_profile:

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

ssh-key z hasłem, z keychain

keychainto małe narzędzie, które zarządza ssh-agentw Twoim imieniu i pozwala ssh-agentpozostać uruchomionym po zakończeniu sesji logowania. Przy kolejnych logowaniach keychainpołączy się z istniejącą ssh-agentinstancją. W praktyce oznacza to, że hasło należy wprowadzić tylko podczas pierwszego logowania po ponownym uruchomieniu. Przy kolejnych logowaniach ssh-agentużywany jest niezaszyfrowany klucz z istniejącej instancji. Może to być również przydatne do zezwalania na uwierzytelnianie RSA / DSA cronbez hasła w zadaniach bez kluczy SSH bez hasła.

Aby włączyć keychain, zainstaluj i dodaj coś takiego ~/.bash_profile:

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

Z punktu widzenia bezpieczeństwa ssh-identi keychainsą gorsze niż ssh-agentprzypadki ograniczone do czasu trwania konkretnej sesji, ale oferują wysoki poziom wygody. Aby poprawić bezpieczeństwo keychain, niektóre osoby dodają --clearopcję do swojego ~/.bash_profilewywołania pęku kluczy. W ten sposób hasła muszą zostać ponownie wprowadzone przy logowaniu, jak wyżej, ale cronzadania nadal będą miały dostęp do niezaszyfrowanych kluczy po wylogowaniu użytkownika. Strona keychain wiki zawiera więcej informacji i przykładów.

klucz ssh bez hasła

Z punktu widzenia bezpieczeństwa jest to najgorsza opcja, ponieważ klucz prywatny jest całkowicie niechroniony na wypadek jego ujawnienia. Jest to jednak jedyny sposób, aby upewnić się, że hasło nie musi być ponownie wprowadzone po ponownym uruchomieniu.

ssh-key z hasłem, z ssh-agent , przekazywanie hasła do ssh-add skryptu

Chociaż przekazywanie hasła do ssh-addskryptu może wydawać się prostym pomysłem , na przykład echo "passphrase\n" | ssh-addnie jest to tak proste, jak się wydaje, ponieważ ssh-add nie odczytuje hasła stdin, ale otwiera się /dev/ttybezpośrednio do odczytu .

Można to obejść za expectpomocą narzędzia do automatyzacji interaktywnych aplikacji. Poniżej znajduje się przykład skryptu, który dodaje klucz ssh przy użyciu hasła zapisanego w skrypcie:

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

Zwróć uwagę, że ponieważ hasło jest przechowywane w skrypcie w postaci zwykłego tekstu, z punktu widzenia bezpieczeństwa nie jest to wcale lepsze niż posiadanie klucza SSH bez hasła. Jeśli ma być zastosowane to podejście, ważne jest, aby upewnić się, że expectskrypt zawierający hasło ma ustawione odpowiednie uprawnienia, dzięki czemu jest czytelny, zapisywalny i uruchamiany tylko przez właściciela klucza.

Dodaj to do swojego ~/.bashrc, a następnie wyloguj się i zaloguj ponownie, aby zastosować.

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

Powinno to monitować o podanie hasła tylko przy pierwszym logowaniu po każdym ponownym uruchomieniu. Będzie używać tego samego ssh-agenttak długo, jak długo będzie działać.

Nie jest ściśle związany z pytaniem PO, ale może być przydatny dla innych: ponieważ 7.2.0 ssh (1) ma opcję, która pozwala dodać klucz do ssh-agent przy pierwszym uwierzytelnieniu; opcja jest AddKeysToAgenti może być ustawiony yes, no, ask, lub confirm, systemowy lub na personal .ssh/configpliku.

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

ssh-agent buforuje różne odblokowane klucze ssh, dzięki czemu możesz mieć klucze ssh chronione hasłem, ale bez konieczności wpisywania ich za każdym razem.

Aby buforować odblokowane klucze, oczywiście trzeba je odblokować. Aby odblokować klucze, które są zablokowane hasłem, oczywiście musi znać te hasła.

Każda metoda, która nie wymaga autoryzacji od człowieka (np. „Wpisanie hasła”) nie tylko spowoduje, że twój system nie będzie bezpieczny; sprawi to, że cały cel ssh-agent będzie bez znaczenia.

Powiedziawszy to wszystko, możesz po prostu użyć kluczy ssh, które nie są chronione hasłem (naciśnij, Entergdy zostaniesz poproszony o hasło podczas generowania klucza). Ponieważ nie ma żadnego hasła, ssh-agentnie trzeba go prosić o (nie) buforowanie.

Oto obejście umożliwiające zautomatyzowanie hasła SSH.

1. Utwórz skrypt jednowierszowy, który wypisze hasło na standardowe wyjście, np .:

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

   Ważne: upewnij się, że skopiujesz wiodące miejsce, aby zapobiec przechowywaniu hasła w historii .

I użyj jednej z poniższych metod.

• przy użyciu standardowego podejścia do wprowadzania danych:

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

• lub nazwane podejście rurowe :

  1. Utwórz nazwany potok (możesz także spróbować podstawienia procesu ):

     mkfifo --mode 0600 ~/.ssh_fifo
     

  2. Uruchom ssh-add, określając program użyty do uwierzytelnienia:

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

  Zobacz: man ssh-addwięcej informacji na temat SSH_ASKPASS.

Nie polecam ci ssh-add (który musi otworzyć ssh-agent) przy logowaniu. Wynika to z faktu, że nie można kontrolować, kiedy kończy się sekcja ssh-agent, i może stwarzać zagrożenie bezpieczeństwa, gdy nie trzeba używać plików kluczy w jednej sekcji logowania.

Radzę raczej napisać skrypt, który otworzy podpowłokę sekcji ssh-agenta, z automatycznie dodanymi wszystkimi plikami kluczy, i będzie wywoływany, gdy zajdzie potrzeba użycia ssh. Jeśli możesz to przyjąć, czytaj dalej.

Masz dwie możliwości:

1. Usuń wszystkie hasła do swoich kluczy, które mają słabe bezpieczeństwo w przypadku kradzieży plików kluczy. (dlatego nie jest zalecane )

2. Użyj tego samego hasła dla swoich kluczy. Wówczas ssh-add keyfile1 keyfile2 ...wystarczy wpisać hasło tylko raz, dla każdej sekcji.

W obu przypadkach możesz napisać taki plik skryptu „ssh_keys_section.sh” jak poniżej:

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

Uwagi:

• Polecenie zmiany lub usunięcia hasła: ssh-keygen -p -f keyfile
• W podpowłoce możesz nawet rozwidlić więcej terminali, które mają takie same odblokowane klucze, używając być może polecenia podobnego /path/to/yourterminal &(zależy od systemu operacyjnego)

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

Kiedyś używałem skryptu wspomnianego przez steampower, teraz zrobiłem poniżej, ponieważ nie pozostawia plików leżących wokół.

Działa zshtylko z powłoką.

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

Uznanie tutaj: https://www.cygwin.com/ml/cygwin/2001-06/msg00537.html

To rozwiązanie jest również zalecane tutaj: http://mah.everybody.org/docs/ssh

Rozwiązanie jednokrotnego logowania dla SSH może mnie do tego doprowadzić pam_ssh.

Zgodnie z tym artykułem koncepcja jest następująca:

Jeśli pracujesz z wieloma maszynami opartymi na * nix przez ssh, prawdopodobnie masz dość ciągłego wprowadzania hasła za każdym razem, gdy chcesz uzyskać dostęp do innego urządzenia. Istnieje bezpieczny sposób, aby umożliwić ci dostęp do każdej maszyny, do której masz dostęp ssh, bez konieczności wprowadzania innego hasła (innego niż to, na którym logowałeś się pierwotnie).

Jest to w rzeczywistości dość proste do zrobienia, po prostu tworzysz parę kluczy publiczny / prywatny, aby uwierzytelnić się na innych komputerach, a następnie PAM spawn uruchamia agenta, który załaduje twoje klucze po zalogowaniu, zapewniając jedno rozwiązanie logowania do uzyskania dostępu do wszystkich zdalnych maszyny Ten przewodnik przeprowadzi Cię przez proces konfiguracji.

Nie sprawdziłem, czy to faktycznie zadziała.

Dodaj to do swojego ~/.bashrcpliku:

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

Aby dodać (możliwie bez hasła) klucz i upewnić się, że ssh-addnie będzie monitował o hasło, bez względu na wszystko, nawet jeśli działa pod X :

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

Status wyjścia wskazuje na sukces lub porażkę.

Jeśli prowadzisz konika morskiego jako menedżera haseł ... Który prawdopodobnie jesteś; D

Innym rozwiązaniem, które osiąga cel, którego szukasz, jest po prostu dodanie kluczy ssh do konika morskiego w celu automatycznego odblokowania po zalogowaniu. Główną zaletą tego jest to, że nigdy nie musisz wprowadzać hasła do kluczy po zalogowaniu przez gdm, ani przy logowaniu się, nawet jeśli klucze mają hasło. Wymaga to zarówno klucza prywatnego, jak i klucza publicznego. MUSZĄ także przestrzegać konwencji nazewnictwa dla konika morskiego. Domyślne jest akceptowalne (id_rsa dla klucza prywatnego i id_rsa.pub dla klucza publicznego ... Naprawdę wszystko, co jest nazwa_prywatna i nazwa_prywatna.pub )

Aby dodać ci klucz ssh do konika morskiego w celu automatycznego odblokowania po zalogowaniu; (na fedora25 nie jestem pewien, gdzie ścieżka znajduje się na innych dystrybucjach, chociaż najprawdopodobniej jest bardzo podobna)

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

Dla mnie tak było

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

(konik morski automatycznie przyjmie, że klucz publiczny w moim przypadku to id_rsa.pub)

Po wykonaniu polecenia konik morski otworzy słodkie małe pole hasła gtk, aby wprowadzić hasło do klucza prywatnego. lub po prostu pozostaw puste, jeśli klucz został wygenerowany bez hasła.

Konik morski nie wyświetli monitu, jeśli wszystko pójdzie dobrze. Musisz spróbować ssh na maszynie docelowej. Następnie konik morski wyświetli monit o odblokowanie klucza za pomocą hasła graficznego (TO JEST TYLKO ZDARZYŁO SIĘ RAZ), ale tym razem powinien on wyglądać nieco inaczej; P (jest to również część, w której konik morski robi konika morskiego, aby dodać magię ssh ) i zaoferuj OPCJĘ, aby odblokować klucz po zalogowaniu, musisz zaznaczyć tę opcję, aby osiągnąć cel.

Tylko dlatego, że nie przeczytałem wszystkich odpowiedzi, zalecam cofnięcie tego, co wszyscy powiedzieli ci, aby zrobić z ssh-add przed spróbowaniem tej odpowiedzi. W przeciwnym razie może to spowodować, że coś złego stanie się z kluczami, idk.

Oto ostateczny skrypt.

Zaktualizuj $ PASSW, a następnie skopiuj i wklej go w swoim terminalu

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

Najlepszym sposobem, jaki jestem świadomy, jest użycie skryptu logowania PAM, który dostosowałem z poprzedniej pracy, ponieważ nie mogłem znaleźć satysfakcjonującej odpowiedzi na to pytanie.

Twoje hasło jest przechowywane w postaci zaszyfrowanej hasłem systemowym i dużą funkcją pochodną. Podczas logowania hasło systemowe służy do odszyfrowania hasła i dodania go do agenta.

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

Przewagą nad każdym innym przedstawionym rozwiązaniem jest to, że łączy w sobie bezpieczeństwo równoważne z ręcznym uruchamianiem ssh-add podczas rozruchu przy zerowym wysiłku. Nie wymaga żadnych dodatkowych narzędzi i ma jedną dodatkową zależność, która jest już domyślnie zainstalowana w większości systemów (OpenSSL).

Moja konfiguracja w systemie macOS jest następująca (w .zshrclub .bash_profiledla osób korzystających z bash):

# 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

|| [[ $SSH_AUTH_SOCK == *"/private/tmp/"* ]]Jest to konieczne ze względu na MacOS domyślną wartością jest /private/tmp/com.apple.launchd.SOMETHINGHERE/Listeners. W przeciwnym razie kompleksowa odpowiedź @Thomas Nyman nie powiedzie się, ponieważ $SSH_AUTH_SOCKzawsze jest ustawiona na coś.

Następnie w .zlogout(lub .bash_logoutdla ludzi bash):

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

Testowane na macOS Mojave 10.14.5