Devo creare uno script che immetta automaticamente una password per il sshclient OpenSSH .

Diciamo che ho bisogno di SSH myname@somehostcon la password a1234b.

Ho già provato ...

#~/bin/myssh.sh
ssh myname@somehost
a1234b

...Ma questo non funziona.

Come posso ottenere questa funzionalità in uno script?

Per prima cosa devi installare sshpass .

• Ubuntu / Debian: apt-get install sshpass
• Fedora / CentOS: yum install sshpass
• Arco: pacman -S sshpass

Esempio:

sshpass -p "YOUR_PASSWORD" ssh -o StrictHostKeyChecking=no YOUR_USERNAME@SOME_SITE.COM

Esempio di porta personalizzata:

sshpass -p "YOUR_PASSWORD" ssh -o StrictHostKeyChecking=no YOUR_USERNAME@SOME_SITE.COM:2400

Appunti:

• sshpasspuò anche leggere una password da un file quando -fviene passato il flag.
  • L'uso -fimpedisce di visualizzare la password se il pscomando viene eseguito.
  • Il file in cui è memorizzata la password deve avere autorizzazioni sicure.

Dopo aver cercato una risposta per la domanda per mesi, ho finalmente trovato una soluzione migliore: scrivere una semplice sceneggiatura.

#!/usr/bin/expect

set timeout 20

set cmd [lrange $argv 1 end]
set password [lindex $argv 0]

eval spawn $cmd
expect "assword:"
send "$password\r";
interact

Mettilo a /usr/bin/exp, quindi puoi usare:

• exp <password> ssh <anything>
• exp <password> scp <anysrc> <anydst>

Fatto!

Utilizza l'autenticazione con chiave pubblica: https://help.ubuntu.com/community/SSH/OpenSSH/Keys

Nell'host di origine eseguirlo solo una volta:

ssh-keygen -t rsa # ENTER to every field
ssh-copy-id myname@somehost

Questo è tutto, dopodiché sarai in grado di fare ssh senza password.

È possibile utilizzare uno script prevede. Non ne ho scritto uno da un po 'di tempo ma dovrebbe apparire come di seguito. Dovrai dirigere la sceneggiatura con#!/usr/bin/expect

#!/usr/bin/expect -f
spawn ssh HOSTNAME
expect "login:" 
send "username\r"
expect "Password:"
send "password\r"
interact

Variante I

sshpass -p PASSWORD ssh USER@SERVER

Variante II

#!/usr/bin/expect -f
spawn ssh USERNAME@SERVER "touch /home/user/ssh_example"
expect "assword:"
send "PASSWORD\r"
interact

sshpass + autossh

Un bel vantaggio del già citato sshpassè che puoi usarlo con autossh, eliminando ancora di più l'inefficienza interattiva.

sshpass -p mypassword autossh -M0 -t myusername@myserver.mydomain.com

Ciò consentirà la connessione automatica se, ad esempio, la connessione wifi viene interrotta chiudendo il laptop.

sshpass con una migliore sicurezza

Mi sono imbattuto in questo thread mentre cercavo un modo per accedere a un server impantanato: ci sono voluti più di un minuto per elaborare il tentativo di connessione SSH e sono scaduto prima che potessi inserire una password. In questo caso, volevo poter fornire la mia password immediatamente quando il prompt era disponibile.

(E se non è dolorosamente chiaro: con un server in questo stato, è troppo tardi per impostare un accesso con chiave pubblica.)

sshpassAl salvataggio. Tuttavia, ci sono modi migliori per farlo rispetto a sshpass -p.

La mia implementazione salta direttamente alla richiesta della password interattiva (non si perde tempo a vedere se può avvenire lo scambio di chiavi pubbliche) e non rivela mai la password come testo semplice.

#!/bin/sh
# preempt-ssh.sh
# usage: same arguments that you'd pass to ssh normally
echo "You're going to run (with our additions) ssh $@"

# Read password interactively and save it to the environment
read -s -p "Password to use: " SSHPASS 
export SSHPASS

# have sshpass load the password from the environment, and skip public key auth
# all other args come directly from the input
sshpass -e ssh -o PreferredAuthentications=keyboard-interactive -o PubkeyAuthentication=no "$@"

# clear the exported variable containing the password
unset SSHPASS

Ecco come accedo ai miei server.

ssp <server_ip>

• alias ssp = '/ home / myuser / Documents / ssh_script.sh'
• cat /home/myuser/Documents/ssh_script.sh

#! / Bin / bash

sshpass -p mypassword ssh root @ $ 1

E quindi...

ssp server_ip

# create a file that echo's out your password .. you may need to get crazy with escape chars or for extra credit put ASCII in your password...
echo "echo YerPasswordhere" > /tmp/1
chmod 777 /tmp/1

# sets some vars for ssh to play nice with something to do with GUI but here we are using it to pass creds.
export SSH_ASKPASS="/tmp/1"
export DISPLAY=YOURDOINGITWRONG
setsid ssh root@owned.com -p 22

riferimento: https://www.linkedin.com/pulse/youre-doing-wrong-ssh-plain-text-credentials-robert-mccurdy?trk=mp-reader-card

Non credo di aver visto nessuno suggerire questo e l'OP ha appena detto "script", quindi ...

Avevo bisogno di risolvere lo stesso problema e il mio linguaggio più comodo è Python.

Ho usato la libreria paramiko. Inoltre, avevo anche bisogno di emettere comandi per i quali avrei bisogno di autorizzazioni escalate usando sudo. Si scopre che sudo può accettare la sua password tramite stdin tramite il flag "-S"! Vedi sotto:

import paramiko

ssh_client = paramiko.SSHClient()

# To avoid an "unknown hosts" error. Solve this differently if you must...
ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())

# This mechanism uses a private key.
pkey = paramiko.RSAKey.from_private_key_file(PKEY_PATH)

# This mechanism uses a password.
# Get it from cli args or a file or hard code it, whatever works best for you
password = "password"

ssh_client.connect(hostname="my.host.name.com",
                       username="username",
                       # Uncomment one of the following...
                       # password=password
                       # pkey=pkey
                       )

# do something restricted
# If you don't need escalated permissions, omit everything before "mkdir"
command = "echo {} | sudo -S mkdir /var/log/test_dir 2>/dev/null".format(password)

# In order to inspect the exit code
# you need go under paramiko's hood a bit
# rather than just using "ssh_client.exec_command()"
chan = ssh_client.get_transport().open_session()
chan.exec_command(command)

exit_status = chan.recv_exit_status()

if exit_status != 0:
    stderr = chan.recv_stderr(5000)

# Note that sudo's "-S" flag will send the password prompt to stderr
# so you will see that string here too, as well as the actual error.
# It was because of this behavior that we needed access to the exit code
# to assert success.

    logger.error("Uh oh")
    logger.error(stderr)
else:
    logger.info("Successful!")

Spero che questo aiuti qualcuno. Il mio caso d'uso era la creazione di directory, l'invio e l'estrazione di file e l'avvio di programmi su ~ 300 server alla volta. Come tale, l'automazione era fondamentale. Ho provato sshpass, expecte poi ho pensato a questo.

Ho funzionato come segue

.ssh / config è stato modificato per eliminare il prompt yes / no - Sono protetto da un firewall, quindi non sono preoccupato per le chiavi ssh contraffatte

host *
     StrictHostKeyChecking no

Creare un file di risposta per aspettarsi, ad esempio answer.expect

set timeout 20
set node [lindex $argv 0]
spawn ssh root@node service hadoop-hdfs-datanode restart

expect  "*?assword {
      send "password\r"   <- your password here.

interact

Crea il tuo script bash e basta chiamare aspettarsi nel file

#!/bin/bash
i=1
while [$i -lt 129]    # a few nodes here

  expect answer.expect hadoopslave$i

  i=[$i + 1]
  sleep 5

done

Ottiene 128 codici dati hadoop aggiornati con la nuova configurazione - supponendo che si stia utilizzando un mount NFS per i file hadoop / conf

Spero che questo aiuti qualcuno - Sono un intorpidito di Windows e mi ci sono volute circa 5 ore per capire!

Se lo stai facendo su un sistema Windows, puoi usare Plink (parte di PuTTY).

plink your_username@yourhost -pw your_password

Ho una soluzione migliore che include l'accesso con il tuo account piuttosto che passare all'utente root. È uno script bash

http://felipeferreira.net/index.php/2011/09/ssh-automatic-login/

La risposta di @abbotto non ha funzionato per me, ha dovuto fare alcune cose in modo diverso:

1. yum install sshpass è stato modificato in - rpm -ivh http://dl.fedoraproject.org/pub/epel/6/x86_64/sshpass-1.05-1.el6.x86_64.rpm
2. il comando per usare sshpass è cambiato in - sshpass -p "pass" ssh user @ mysite -p 2122

Sono riuscito a farlo funzionare con quello:

SSH_ASKPASS="echo \"my-pass-here\""
ssh -tt remotehost -l myusername

Nell'esempio seguente scriverò la soluzione che ho usato:

Lo scenario: voglio copiare il file da un server usando sh script:

#!/usr/bin/expect
$PASSWORD=password
my_script=$(expect -c "spawn scp userName@server-name:path/file.txt /home/Amine/Bureau/trash/test/
expect \"password:\"
send \"$PASSWORD\r\"
expect \"#\"
send \"exit \r\"
")

echo "$my_script"

Usa questo script all'interno dello script, il primo argomento è il nome host e il secondo sarà la password.

#!/usr/bin/expect
set pass [lindex $argv 1]
set host [lindex $argv 0]
spawn ssh -t root@$host echo Hello
expect "*assword: " 
send "$pass\n";
interact"

Per connettere la macchina remota tramite script di shell, utilizzare il comando seguente:

sshpass -p PASSWORD ssh -o StrictHostKeyChecking=no USERNAME@IPADDRESS

dove IPADDRESS, USERNAMEe PASSWORDsono i valori di input che hanno bisogno di fornire nello script, o se vogliamo fornire in uso runtime "leggere" il comando.

sudo ssh username@server_ip_address -p port_number

premere il tasto Invio, quindi immettere la password del sistema e infine immettere la password del server