Necesito crear un script que ingrese automáticamente una contraseña para el sshcliente OpenSSH .

Digamos que necesito ingresar SSH myname@somehostcon la contraseñaa1234b .

Ya lo he intentado ...

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

...Pero esto no funciona.

¿Cómo puedo obtener esta funcionalidad en un script?

Primero necesitas instalar sshpass .

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

Ejemplo:

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

Ejemplo de puerto personalizado:

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

Notas:

• sshpassTambién puede leer una contraseña de un archivo cuando -fse pasa la bandera.
  • El uso -fevita que la contraseña sea visible si psse ejecuta el comando.
  • El archivo en el que se almacena la contraseña debe tener permisos seguros.

Después de buscar una respuesta para la pregunta durante meses, finalmente encontré una mejor solución: escribir un guión simple.

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

Póngalo en /usr/bin/exp, luego puede usar:

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

¡Hecho!

Utilice la autenticación de clave pública: https://help.ubuntu.com/community/SSH/OpenSSH/Keys

En el host de origen, ejecute esto solo una vez:

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

Eso es todo, después de eso podrás hacer ssh sin contraseña.

Podría usar un script de espera. No he escrito uno en bastante tiempo, pero debería verse a continuación. Deberá encabezar el guión 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

Una buena ventaja de lo ya mencionado sshpasses que puede usarlo autossh, eliminando aún más la ineficiencia interactiva.

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

Esto permitirá la conexión automática si, por ejemplo, su wifi se interrumpe al cerrar su computadora portátil.

sshpass con mejor seguridad

Me topé con este hilo mientras buscaba una forma de ingresar a un servidor atascado: me llevó más de un minuto procesar el intento de conexión SSH y agotó el tiempo de espera antes de que pudiera ingresar una contraseña. En este caso, quería poder proporcionar mi contraseña de inmediato cuando el aviso estuviera disponible.

(Y si no es dolorosamente claro: con un servidor en este estado, es demasiado tarde para configurar un inicio de sesión de clave pública).

sshpassal rescate. Sin embargo, hay mejores formas de hacerlo que sshpass -p.

Mi implementación salta directamente a la solicitud de contraseña interactiva (no se pierde tiempo viendo si puede ocurrir un intercambio de clave pública), y nunca revela la contraseña como texto sin formato.

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

Así es como inicio sesión en mis servidores.

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

Y por lo tanto...

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

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

No creo haber visto a nadie sugerir esto y el OP simplemente dijo "guión", así que ...

Necesitaba resolver el mismo problema y mi lenguaje más cómodo es Python.

Usé la biblioteca paramiko. Además, también necesitaba emitir comandos para los que necesitaría usar permisos escalados sudo. Resulta que sudo puede aceptar su contraseña a través de stdin a través de la bandera "-S". Vea abajo:

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!")

Espero que esto ayude a alguien. Mi caso de uso fue crear directorios, enviar y descomprimir archivos e iniciar programas en ~ 300 servidores a la vez. Como tal, la automatización era primordial. Lo intenté sshpass, expecty luego se me ocurrió esto.

Obtuve esto funcionando de la siguiente manera

.ssh / config se modificó para eliminar el mensaje yes / no: estoy detrás de un firewall, así que no me preocupan las claves ssh falsas

host *
     StrictHostKeyChecking no

Cree un archivo de respuesta para esperar, es decir, 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

Cree su script bash y solo llame a wait en el archivo

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

  expect answer.expect hadoopslave$i

  i=[$i + 1]
  sleep 5

done

Obtiene 128 nodos de datos hadoop actualizados con una nueva configuración, suponiendo que esté utilizando un montaje NFS para los archivos hadoop / conf

Espero que esto ayude a alguien: soy un Windows numpty y esto me tomó alrededor de 5 horas para descubrirlo.

Si está haciendo esto en un sistema Windows, puede usar Plink (parte de PuTTY).

plink your_username@yourhost -pw your_password

Tengo una mejor solución que incluye el inicio de sesión con su cuenta que cambiar a usuario root. Es un script bash

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

La respuesta de @abbotto no funcionó para mí, tenía que hacer algunas cosas de manera diferente:

1. yum install sshpass cambió a - rpm -ivh http://dl.fedoraproject.org/pub/epel/6/x86_64/sshpass-1.05-1.el6.x86_64.rpm
2. el comando para usar sshpass cambió a - sshpass -p "pass" ssh user @ mysite -p 2122

Me las arreglé para que funcione con eso:

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

En el siguiente ejemplo, escribiré la solución que usé:

El escenario: quiero copiar el archivo de un servidor usando el script sh:

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

Use esta secuencia de comandos dentro de la secuencia de comandos, el primer argumento es el nombre de host y el segundo será la contraseña.

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

Para conectar la máquina remota a través de scripts de shell, use el siguiente comando:

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

donde IPADDRESS, USERNAMEy PASSWORDson valores de entrada que deben proporcionarse en el script, o si queremos proporcionar en tiempo de ejecución, use el comando "leer".

sudo ssh username@server_ip_address -p port_number

presione la tecla enter y luego ingrese la contraseña de su sistema y finalmente ingrese la contraseña de su servidor