Czy możesz ustawić hasła w .ssh / config, aby umożliwić automatyczne logowanie?

Używam Ubuntu 11.10. Używam sshdo łączenia się z wieloma serwerami codziennie, więc umieszczam ich parametry w .ssh/configpliku w następujący sposób:

Host Home
User netmoon
Port 22
HostName test.com

Czy istnieje sposób na umieszczenie haseł dla każdego połączenia w tym pliku, aby gdy serwer poprosił o hasło, terminal wprowadził swoje hasło i wysłał je na serwer?

Potrzebuję tego, ponieważ czasami odstaję od komputera, a kiedy wracam, wpisz hasło i naciśnij Enterterminal mówi CONNECTION CLOSED.

PS Nie chcę używać pary kluczy publiczny / prywatny.

Zamiana bezpieczeństwa dla wygody nigdy się nie kończy dobrze ...

Czy możesz użyć ssh-copy-idz openssh-clientpaczki?

Od man ssh-copy-id:

ssh-copy-id to skrypt, który używa ssh do zalogowania się na zdalnym komputerze i dołączenia wskazanego pliku tożsamości do pliku ~ / .ssh / Author_keys tego komputera.

Jeśli tak naprawdę nie chcesz używać pary kluczy publiczny / prywatny, możesz napisać expectskrypt, który automatycznie wprowadzi hasło w zależności od adresu docelowego.

Edycja: Mam na myśli to, że możesz mieć skrypt, który z jednej strony używa expecthasła do ciebie, az drugiej strony odczytuje hasło dla danego użytkownika i hosta z pliku konfiguracyjnego. Na przykład następujący skrypt w języku Python będzie działał w scenariuszu ze słonecznym dniem:

#!/usr/bin/python                                                                                                                        
import argparse
from ConfigParser import ConfigParser
import pexpect

def main(args):
    url = args.url
    user, host = url.split('@', 1)

    cfg_file = 'ssh.cfg'
    cfg = ConfigParser()
    cfg.read(cfg_file)
    passwd = cfg.get(user, host)

    child = pexpect.spawn('ssh {0}'.format(url))
    child.expect('password:')
    child.sendline(passwd)
    child.interact()

if __name__ == '__main__':
    parser = argparse.ArgumentParser(description='Run ssh through pexpect')
    parser.add_argument('url')
    args = parser.parse_args()
    main(args)

a format pliku konfiguracyjnego byłby następujący:

[user_1]
host1 = passwd_1
host2 = passwd_2

[user_2]
host1 = passwd_1
host2 = passwd_2

Uwaga: Jak wyjaśniono, skrypt w języku Python musiałby być znacznie bardziej skomplikowany, aby obsłużyć wszystkie możliwe błędy i komunikaty pytań z ssh i wszystkich możliwych adresów URL (w przykładzie założono, że będzie to coś podobnego user@host, ale część użytkownika nie jest używane przez większość czasu), ale podstawowa idea pozostanie taka sama. Jeśli chodzi o plik konfiguracyjny, możesz użyć innego pliku konfiguracyjnego lub użyć .ssh/configi napisać własny kod, aby przeanalizować ten plik i uzyskać hasło dla danego użytkownika i hosta.

Istnieje również sshpassprogram do tego. Jak używać: sshpass -p MyPa55word ssh [email protected]

Co z ProxyCommand:

Host Home-raw
    HostName test.com
Host Home
   User netmoon
   Port 22
   ProxyCommand sshpass -pmypass ssh netmoon@%h-raw nc localhost %p

Możesz użyć ssh -Wzamiast nc:

ProxyCommand sshpass -pmypass ssh netmoon@%h-raw -W localhost:%p

Nie. Obawiam się, że to niemożliwe.

Jedyną prawdziwą alternatywą jest używanie kluczy prywatnych, ale powiedziałeś, że nie chcesz (dlaczego nie?).

Możesz utworzyć prostą zamianę skryptu ssh w / usr / local / bin:

#!/bin/bash

host=$1
password=`awk "/#Password/ && inhost { print \\\$2 } /Host/ { inhost=0 } /Host $host/ { inhost=1 }" ~/.ssh/config`

if [[ -z "$password" ]]; then
  /usr/bin/ssh $*
else
  sshpass -p $password /usr/bin/ssh $*
fi

A następnie w pliku ~ / .ssh / config możesz użyć

Host foohost
    User baruser
    #Password foobarpassword

Korzystam z aplikacji VanDyke Software o nazwie SecureCRT .

http://www.vandyke.com/products/securecrt/

To nie jest darmowe, ale w bardzo przystępnej cenie. Używam go od lat (działając w systemie Windows lub Wine) do zdalnego dostępu, emulacji terminala i (rozproszonego) zarządzania siecią. W końcu wydali natywną wersję Linuksa na początku 2011 roku.

Obsługuje złożone ustawienia logowania (lub skrypty), przechowywane hasła (lub certyfikaty), wiele sesji na kartach itp.

Podczas uruchamiania możesz wybrać, który zdalny cel (i protokół) z ustrukturyzowanej listy (widoku drzewa) przechowywanych zdalnych (lub lokalnych) maszyn, lub po prostu utworzyć połączenie (które jest następnie przechowywane).

Uważam, że jest to szczególnie przydatne w przypadku zdalnych witryn z zaawansowanym uwierzytelnianiem, niestandardowymi portami lub negocjacjami dotyczącymi dostępu do zapory.

Jeśli często korzystasz z dostępu zdalnego (część swojej głównej roli), ta aplikacja uzasadni swój koszt w pierwszym miesiącu użytkowania.

Odpowiadając na zadane pytanie, nie, nie można skonfigurować domyślnego hasła w pliku konfiguracyjnym ssh.

Ale jeśli rzeczywiście, jak mówisz, jest to „ponieważ czasami odstaję od komputera i kiedy wracam, wpisz hasło i naciśnij Enterterminal mówi CONNECTION CLOSED” , to dlaczego nie zapobiec zamknięciu sesji? SSH może utrzymywać połączenia dla Ciebie.

Host Home
  User netmoon
  Port 22
  HostName test.com
  ServerAliveInterval 300
  ServerAliveCountMax 2

Dzięki, Arek za inspirację ...

Zamiast uruchamiania innego procesu powłoki, jest to tylko funkcja działająca w bieżącej powłoce bash. Prowadzi jednego awkpolecenia do analizowania pliku konfiguracyjnego i dowiedzieć się, czy powinien wziąć hasło ze zmiennej powłoki lub z hasłem napisany w czystym tekście do pliku konfiguracyjnego ssh (z awkw sposób evalzamiast describez powodu problemów uderzę użyciu describe).

Próbowałem tak wielu sposobów używania sshpassbezpośrednio w sshpliku konfiguracyjnym za pomocą ProxyCommand, ale nic nie działało zgodnie z oczekiwaniami, z wyjątkiem sytuacji, gdy mogłem zalogować się do skrzynki za pośrednictwem RSA. Ale potem musiałem wysłać hasło, aby otworzyć mój zaszyfrowany katalog. Jednak moja funkcja poniżej wydaje się działać dla mnie we wszystkich przypadkach, nawet dla Cygwin.

# In your .bash_profile
function ssh(){
    host=$1;
    unset PASSWORD
    unset PASSVAR
    eval $(awk "/ *#[Pp]assvar / && inhost { printf \"PASSVAR=%s\",\$2; exit 1 } / *#[Pp]assword / && inhost { printf \"PASSWORD=%s\",\$2; } /^#?[Hh][oO][sS][tT] / && inhost { inhost=0; exit 1 } /^[Hh][oO][sS][tT] $host\$/ { inhost=1 }" ~/.ssh/config)
    if [[ -z "$PASSWORD" ]] && [[ -z "$PASSVAR" ]]; then
        /usr/bin/ssh -q $* 2>/dev/null
    else
       if [[ -n "$PASSVAR" ]]; then
          PASSWORD=$(TMP=${!PASSVAR-*};echo ${TMP##*-})
       fi
       /usr/local/bin/sshpass -p"$PASSWORD" /usr/bin/ssh -q $* 2>/dev/null
    fi
}
# and setup your passwords (perhaps in .bashrc instead...)
MYPASS_ENVVAR=SomePassword
MYPASSWD_FROM_FILE=$(</home/me/.passwd_in_file)

Następnie ~/.ssh/configsekcja wygląda następująco:

Host MyHostname
 Port 22
 Hostname 2.1.2.2
 User merrydan
 #Passvar MYPASS_ENVVAR
 #Password Some!Password

Jeśli #Passvar istnieje sekcja konfiguracji, to zastępuje #Password.
$MYPASS_ENVVARto zmienna środowiskowa przechowująca twoje hasło.

Cieszyć się!

Odpowiedź @BrunoPereira na to pytanie pokazuje alternatywną metodę połączenia bez jawnego wprowadzania hasła i unikania kluczy ssh.

Możesz utworzyć skrypt, alias lub funkcję, ~/.bashrcaby szybko wykonać to polecenie.

Oczywiście są to względy bezpieczeństwa, które należy wziąć pod uwagę przy takim podejściu.

Oto moja rozbudowana odmiana odpowiedzi @ ArekBurdach. Oferuje następujące rozszerzenia:

• gospodarza mogą być w dowolnym miejscu w sshlinii poleceń; tzn. obsługuje również ssh <args> <host> <commands>składnię
• nie koduje na stałe ścieżki do ssh
• bardziej niezawodne parsowanie ssh_config
• Bonus: nakładka na scpzbyt

ssh-wrapper

#!/bin/bash

password=$(awk '
BEGIN {
    # Collect the SSH arguments as keys of a dictionary, so that we can easily
    # check for inclusion.
    for (i = 2; i < ARGC; i++) {
        sshArgs[ARGV[i]] = 1
    }

    # Only process the first argument; all others are the command-line arguments
    # given to ssh.
    ARGC = 2
}
$1 == "Password" && inhost { print $2 }
/^\s*Host\s/ {
    if ($2 in sshArgs)
        inhost=1
    else
        inhost=0
}
' ~/.ssh/config "$@")


if [ "$password" ]; then
    sshpass -p "$password" "$(which ssh)" "$@"
else
    "$(which ssh)" "$@"
fi

scp-wrapper

#!/bin/bash

password=$(awk '
BEGIN {
    # Collect the SCP arguments as keys of a dictionary, so that we can easily
    # check for inclusion.
    for (i = 2; i < ARGC; i++) {
        colonIdx = index(ARGV[i], ":")
        if (colonIdx > 0) {
            scpArgs[substr(ARGV[i], 1, colonIdx - 1)] = 1
        }
    }

    # Only process the first argument; all others are the command-line arguments
    # given to scp.
    ARGC = 2
}
$1 == "Password" && inhost { print $2 }
/^\s*Host\s/ {
    if ($2 in scpArgs)
        inhost=1
    else
        inhost=0
}
' ~/.ssh/config "$@")


if [ "$password" ]; then
    sshpass -p "$password" "$(which scp)" "$@"
else
    "$(which scp)" "$@"
fi

Instalacja

Zdefiniuj aliasy w swoim ~/.bashrc:

alias ssh=ssh-wrapper
alias scp=scp-wrapper

Konfiguracja

Dzięki IgnoreUnknowndyrektywie sshnie narzeka na nowo wprowadzoną Passworddyrektywę, więc (w przeciwieństwie do odpowiedzi @ ArekBurdach) możemy sprawić, że będzie to wyglądać jak „prawdziwa” konfiguracja. Jeśli ci się to nie podoba, zmiana skryptu na skomentowany jest banalnie.

# Allow specifying passwords for Host entries, to be parsed by ssh-wrapper.
IgnoreUnknown Password

Host foohost
    User baruser
    Password foobarpassword

Jeśli nie masz bezpośredniego dostępu do pary kluczy, możesz zaszyfrować hasło na komputerze lokalnym.

Sposobem na to jest zaszyfrowanie hasła przy użyciu klucza oprócz ProxyCommand @Eric Woodruff.

Jednym ze sposobów łączenia jest użycie potoku:

openssl rsautl -decrypt -inkey /path/to/decrypt_key -in /path/to/encrypted_password  | sshpass ssh real-destination -tt

gdzie

Host real-destination
    Hostname test.com
    User netmoon

Istnieje niewielki wariant sposobu opisanego na blogu, w jaki sposób korzystać, sshpass który można znaleźć tutaj . Biorąc pod uwagę, że masz zaszyfrowane hasło gpg (jak to opisano w blogu), możesz zrobić coś takiego:

 sshpass -p $(echo $(gpg -d -q .sshpasswd.gpg)) ssh your_desination.xyz

i po prostu zapisz to polecenie jako alias w swoim .bashrc.

Jeśli chcesz tunelować przez to połączenie, możesz zrobić coś takiego

 Host actual_dest
      Hostname actual.dest.xyz
      User username
      ProxyCommand sshpass -p $(echo $(gpg -d -q ~/.sshpasswd.gpg)) \ 
                   ssh your_destination.xyz nc %h %p