Puoi impostare le password in .ssh / config per consentire l'accesso automatico?

Sto usando Ubuntu 11.10. Sto usando sshper connettermi a molti server ogni giorno, quindi inserisco i loro parametri nel .ssh/configfile in questo modo:

Host Home
User netmoon
Port 22
HostName test.com

Esiste un modo per inserire le password per ogni connessione in questo file, in modo che, quando il server richiede la password, il terminale inserisca la sua password e la mandi al server?

Ho bisogno di questo perché a volte mi distacco dal PC e quando torno, digitare una password e premere Enteril terminale dice CONNECTION CLOSED.

PS Non voglio usare una coppia di chiavi pubblica / privata.

Negoziare sicurezza per comodità non finisce mai bene ...

Potresti usare ssh-copy-iddal openssh-clientpacchetto?

Da man ssh-copy-id:

ssh-copy-id è uno script che utilizza ssh per accedere a una macchina remota e aggiungere il file di identità indicato al file ~ / .ssh / authorized_keys di quella macchina.

Se non si desidera realmente utilizzare una coppia di chiavi pubblica / privata, è possibile scrivere uno expectscript per inserire automaticamente la password in base all'indirizzo di destinazione.

Modifica: voglio dire che puoi avere uno script che, da un lato, utilizza expectper inserire la password per te e, dall'altro, legge la password per un determinato utente e host da un file di configurazione. Ad esempio, il seguente script python funzionerà per lo scenario di una giornata di sole:

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

e il formato del file di configurazione sarebbe il seguente:

[user_1]
host1 = passwd_1
host2 = passwd_2

[user_2]
host1 = passwd_1
host2 = passwd_2

Nota: Come spiegato, lo script python dovrebbe essere molto più complesso per gestire tutti i possibili errori e messaggi di domande da ssh e tutti i possibili URL (nell'esempio si presume che sarà qualcosa di simile user@host, ma la parte utente non è ' ho usato la maggior parte delle volte), ma l'idea di base sarebbe sempre la stessa. Per quanto riguarda il file di configurazione, è possibile utilizzare un file di configurazione diverso o utilizzare .ssh/confige scrivere il proprio codice per analizzare quel file e ottenere la password per un determinato utente e host.

C'è anche un sshpassprogramma per questo. Come usare: sshpass -p MyPa55word ssh me@myservor.com

Che ne dici di ProxyCommand:

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

Puoi usare anche al ssh -Wposto di nc:

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

No. Questo non è possibile, temo.

L'unica vera alternativa è usare le chiavi private ma hai detto che non vuoi (perché no?).

Puoi creare una semplice sostituzione di script ssh in / 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

E poi nel tuo file ~ / .ssh / config puoi usare

Host foohost
    User baruser
    #Password foobarpassword

Uso un'applicazione del software VanDyke chiamata SecureCRT .

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

Non è gratuito, ma a prezzi molto ragionevoli. L'ho usato per anni (in esecuzione su Windows o utilizzando Wine) per l'accesso remoto, l'emulazione di terminale e la gestione della rete (dispersa). Hanno finalmente rilasciato una versione nativa di Linux all'inizio del 2011.

Supporta impostazioni di accesso complesse (o script), password memorizzate (o certificati), sessioni multiple a schede, ecc.

All'avvio è possibile scegliere quale target remoto (e protocollo) da un elenco strutturato (vista ad albero) di macchine remote (o locali) memorizzate, o semplicemente creare una connessione (che viene quindi memorizzata).

L'ho trovato particolarmente utile per i siti remoti con autenticazione avanzata, porte non standard o negoziazione dell'accesso al firewall.

Se stai effettuando molto l'accesso remoto (parte del tuo ruolo principale), questa applicazione giustificherà le sue spese nel primo mese di utilizzo.

Rispondendo alla domanda che hai posto, no non è possibile configurare una password predefinita in un file di configurazione ssh.

Ma se davvero, come dici tu, è "perché a volte mi distacco dal PC e quando torno, digitare una password e premere Enteril terminale dice CONNECTION CLOSED" , allora perché non impedire invece di chiudere la sessione? SSH può mantenere vive le connessioni per te.

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

Grazie, Arek per l'ispirazione ...

Invece di eseguire un altro processo di shell, questa è solo una funzione in esecuzione nella shell bash corrente. Esegue un singolo awkcomando per analizzare il file di configurazione e capire se dovrebbe prendere la password da una variabile di shell o dalla password scritta in chiaro nel file di configurazione di ssh (con awkin evalinvece che a describecausa di problemi che ho colpito usando describe).

Ho provato così tanti modi di utilizzare sshpassdirettamente in un sshfile di configurazione usando ProxyCommand, ma nulla sembrava funzionare come previsto, tranne quando potevo accedere a un box tramite RSA. Ma poi avevo bisogno di inviare una password per aprire la mia directory crittografata. Tuttavia, la mia funzione di seguito sembra funzionare per me in tutti i casi, anche per 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)

Quindi una ~/.ssh/configsezione è simile alla seguente:

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

Se #Passvar nella sezione di configurazione esiste un , questo sostituisce il #Password.
$MYPASS_ENVVARè la variabile d'ambiente che contiene la tua password.

Godere!

La risposta di @BrunoPereira a questa domanda mostra un metodo alternativo per connettersi senza inserire esplicitamente una password ed evitare le chiavi ssh.

È possibile creare uno script, un alias o una funzione nel proprio ~/.bashrcper eseguire rapidamente quel comando.

Ovviamente, ci sono considerazioni sulla sicurezza che dovresti prendere in considerazione con questo approccio.

Ecco la mia elaborata variazione sulla risposta di @ ArekBurdach. Offre le seguenti estensioni:

• l' host può trovarsi ovunque nella sshriga di comando; cioè supporta anche la ssh <args> <host> <commands>sintassi
• non codifica il percorso per ssh
• analisi più robusta di ssh_config
• Bonus: wrapper per scp, troppo

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

Installazione

Definisci gli alias nel tuo ~/.bashrc:

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

Configurazione

Con la IgnoreUnknowndirettiva, sshnon ci si lamenta di una Passworddirettiva appena introdotta , quindi (contrariamente alla risposta di @ ArekBurdach), possiamo far apparire questa come una configurazione "reale". Se non ti piace, è banale riportare lo script in quello commentato.

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

Host foohost
    User baruser
    Password foobarpassword

Se non si dispone dell'accesso diretto alla coppia di chiavi, è possibile crittografare la password sul proprio computer locale.

Il modo per farlo è crittografare la password usando la chiave oltre al ProxyCommand di @Eric Woodruff.

Un modo per combinare è usare pipe:

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

dove

Host real-destination
    Hostname test.com
    User netmoon

C'è una leggera variante di un modo descritto nel blog su come usare sshpass che può essere trovato qui . Dato che hai un file con password crittografata gpg (come è descritto nel blog) potresti fare qualcosa del genere:

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

e semplicemente salva quel comando come alias nel tuo .bashrc.

Se vuoi scavalcare questa connessione, potresti fare qualcosa del genere

 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