¿Puede establecer contraseñas en .ssh / config para permitir el inicio de sesión automático?

Estoy usando Ubuntu 11.10. Estoy usando sshpara conectarme a muchos servidores diariamente, así que pongo sus parámetros en el .ssh/configarchivo de esta manera:

Host Home
User netmoon
Port 22
HostName test.com

¿Hay alguna forma de poner contraseñas para cada conexión en este archivo, de modo que, cuando el servidor solicita la contraseña, el terminal ingresa su contraseña y la envía al servidor?

Necesito esto porque a veces me mantengo alejado de la PC y cuando regreso, escribo una contraseña y presiono Enterel terminal dice CONNECTION CLOSED.

PD: No quiero usar un par de claves pública / privada.

Cambiar la seguridad por conveniencia nunca termina bien ...

¿Podrías usar ssh-copy-iddel openssh-clientpaquete?

De man ssh-copy-id:

ssh-copy-id es un script que usa ssh para iniciar sesión en una máquina remota y agregar el archivo de identidad indicado al archivo ~ / .ssh / Authorizedkeys de esa máquina.

Si realmente no desea utilizar un par de claves pública / privada, puede escribir un expectscript para ingresar la contraseña automáticamente según la dirección de destino.

Editar: lo que quiero decir es que puede tener una secuencia de comandos que, por un lado, utiliza expectpara ingresar la contraseña y, por otro lado, lee la contraseña de un usuario y host desde un archivo de configuración. Por ejemplo, el siguiente script de Python funcionará para el escenario de día soleado:

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

y el formato del archivo de configuración sería el siguiente:

[user_1]
host1 = passwd_1
host2 = passwd_2

[user_2]
host1 = passwd_1
host2 = passwd_2

Nota: Como se explicó, la secuencia de comandos de Python debería ser mucho más compleja para manejar todos los posibles errores y mensajes de preguntas de ssh y todas las URL posibles (en el ejemplo se supone que será algo así user@host, pero la parte del usuario no es ' t utilizado la mayoría de las veces), pero la idea básica seguiría siendo la misma. Con respecto al archivo de configuración, puede usar un archivo de configuración diferente o usar .ssh/configy escribir su propio código para analizar ese archivo y obtener la contraseña para un usuario y host determinados.

También hay un sshpassprograma para eso. Cómo utilizar: sshpass -p MyPa55word ssh me@myservor.com

¿Qué hay de ProxyCommand:

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

Puede usar en ssh -Wlugar de nctambién:

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

No. Esto no es posible, me temo.

La única alternativa real es usar claves privadas, pero has dicho que no quieres (¿por qué no?).

Puede crear un reemplazo simple de script ssh en / 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

Y luego en su archivo ~ / .ssh / config puede usar

Host foohost
    User baruser
    #Password foobarpassword

Yo uso una aplicación de VanDyke Software llamada SecureCRT .

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

No es gratis, pero tiene un precio muy razonable. Lo he usado durante años (ejecutándose en Windows o usando Wine) para acceso remoto, emulación de terminal y administración de red (dispersa). Finalmente lanzaron una versión nativa de Linux a principios de 2011.

Tiene soporte para configuraciones de inicio de sesión complejas (o scripts), contraseñas almacenadas (o certificados), múltiples sesiones con pestañas, etc.

Al inicio, puede elegir qué destino remoto (y protocolo) de una lista estructurada (vista de árbol) de máquinas remotas (o locales) almacenadas, o simplemente crear una conexión (que luego se almacena).

Lo he encontrado particularmente útil para sitios remotos con autenticación avanzada, puertos no estándar o negociación de acceso a firewall.

Si está haciendo mucho acceso remoto (parte de su función principal), esta aplicación justificará su gasto en el primer mes de uso.

Respondiendo la pregunta que hizo, no, no es posible configurar una contraseña predeterminada en un archivo de configuración ssh.

Pero si, como usted dice, es "porque a veces me alejo de la PC y cuando regreso, escribo una contraseña y presiono Enterel terminal dice CONNECTION CLOSED" , entonces ¿por qué no evitar cerrar la sesión? SSH puede mantener las conexiones vivas para usted.

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

Gracias, Arek por la inspiración ...

En lugar de ejecutar otro proceso de shell, esta es solo una función que se ejecuta en el shell bash actual. Ejecuta un solo awkcomando para analizar el archivo de configuración y determinar si debe tomar la contraseña de una variable de shell o del texto sin cifrar escrito en el archivo de configuración ssh ( awken evallugar de describedebido a problemas que utilicé describe).

Probé muchas formas de usar sshpassdirectamente en un ssharchivo de configuración usando ProxyCommand, pero nada parecía funcionar como se esperaba, excepto cuando podía iniciar sesión en un cuadro a través de RSA. Pero luego necesitaba enviar una contraseña para abrir mi directorio encriptado. Sin embargo, mi función a continuación parece funcionar para mí en todos los casos, incluso para 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)

Entonces una ~/.ssh/configsección se ve así:

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

Si #Passvar existe una en la sección de configuración, esto anula el #Password.
$MYPASS_ENVVARes la variable de entorno que contiene su contraseña.

¡Disfrutar!

La respuesta de @BrunoPereira a esta pregunta muestra un método alternativo para conectarse sin ingresar explícitamente una contraseña y evitar las claves ssh.

Puede crear un script, un alias o una función en su ~/.bashrcpara ejecutar rápidamente ese comando.

Obviamente, hay consideraciones de seguridad que debe tener en cuenta con este enfoque.

Aquí está mi variación elaborada sobre la respuesta de @ ArekBurdach. Ofrece las siguientes extensiones:

• el host puede estar en cualquier lugar de la sshlínea de comandos; es decir, también es compatible con la ssh <args> <host> <commands>sintaxis
• no codifica la ruta a ssh
• análisis más robusto de ssh_config
• Bono: envoltorio para scp, también

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

Instalación

Defina alias en su ~/.bashrc:

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

Configuración

Con la IgnoreUnknowndirectiva, sshno se queja de una Passworddirectiva recién presentada , por lo que (en contraste con la respuesta de @ ArekBurdach), podemos hacer que esto aparezca como una configuración "real". Si no le gusta esto, es trivial volver a cambiar el guión al comentado.

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

Host foohost
    User baruser
    Password foobarpassword

Si no tiene acceso directo al par de claves, puede cifrar la contraseña en su máquina local.

La forma de hacerlo es encriptar su contraseña usando la clave además del ProxyCommand de @Eric Woodruff.

Una forma de combinar es usar tubería:

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

dónde

Host real-destination
    Hostname test.com
    User netmoon

Hay una ligera variante de una forma descrita en el blog sobre cómo usar sshpass que se puede encontrar aquí . Dado que tiene una contraseña cifrada con gpg (cómo se describe esto en el blog), puede hacer algo como esto:

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

y simplemente guarde ese comando como un alias en su .bashrc.

Si quieres hacer un túnel a través de esa conexión, puedes hacer algo como

 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