Você pode definir senhas em .ssh / config para permitir o login automático?

Estou usando o Ubuntu 11.10. Estou usando sshpara conectar a muitos servidores diariamente, então coloquei seus parâmetros no .ssh/configarquivo assim:

Host Home
User netmoon
Port 22
HostName test.com

Existe uma maneira de colocar senhas para cada conexão neste arquivo, para que, quando o servidor solicite a senha, o terminal insira sua senha e a envie ao servidor?

Eu preciso disso porque às vezes me afasto do PC e, quando volto, digite uma senha e pressione Entero terminal diz CONNECTION CLOSED.

PS: Não quero usar um par de chaves pública / privada.

Negociar segurança por conveniência nunca acaba bem ...

Você poderia usar ssh-copy-iddo openssh-clientpacote?

De man ssh-copy-id:

ssh-copy-id é um script que usa ssh para efetuar login em uma máquina remota e anexar o arquivo de identidade indicado ao arquivo ~ / .ssh / allowed_keys dessa máquina.

Se você realmente não deseja usar um par de chaves pública / privada, pode escrever um expectscript para inserir a senha automaticamente, dependendo do endereço de destino.

Editar: O que quero dizer é que você pode ter um script que, por um lado, usa expectpara inserir a senha para você e, por outro lado, lê a senha para um determinado usuário e host a partir de um arquivo de configuração. Por exemplo, o seguinte script python funcionará para o cenário de dia ensolarado:

#!/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 o formato do arquivo de configuração seria o seguinte:

[user_1]
host1 = passwd_1
host2 = passwd_2

[user_2]
host1 = passwd_1
host2 = passwd_2

Nota: Conforme explicado, o script python precisaria ser muito mais complexo para lidar com todos os possíveis erros e mensagens de perguntas do ssh e todos os URLs possíveis (no exemplo, presume-se que será algo parecido user@host, mas a parte do usuário não é ' usado na maioria das vezes), mas a idéia básica ainda seria a mesma. Em relação ao arquivo de configuração, você pode usar um arquivo de configuração diferente ou usar .ssh/confige escrever seu próprio código para analisar esse arquivo e obter a senha para um determinado usuário e host.

Também existe um sshpassprograma para isso. Como usar: sshpass -p MyPa55word ssh me@myservor.com

Que tal o ProxyCommand:

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

Você pode usar em ssh -Wvez de nc:

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

Não. Isso não é possível, eu tenho medo.

A única alternativa real é usar chaves privadas, mas você disse que não deseja (por que não?).

Você pode criar uma substituição simples de script ssh em / 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 então no seu arquivo ~ / .ssh / config você pode usar

Host foohost
    User baruser
    #Password foobarpassword

Eu uso um aplicativo da VanDyke Software chamado SecureCRT .

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

Não é gratuito, mas com preços muito razoáveis. Eu o uso há anos (executando no Windows ou usando o Wine) para acesso remoto, emulação de terminal e gerenciamento de rede (disperso). Eles finalmente lançaram uma versão nativa do Linux no início de 2011.

Ele suporta configurações complexas de login (ou scripts), senhas armazenadas (ou certificados), várias sessões com guias etc.

Na inicialização, você pode escolher qual destino (e protocolo) remoto a partir de uma lista estruturada (exibição em árvore) de máquinas remotas (ou locais) armazenadas ou apenas criar uma conexão (que será armazenada).

Eu o achei particularmente útil para sites remotos com autenticação avançada, portas não padrão ou negociação de acesso por firewall.

Se você estiver acessando muito remotamente (parte de sua função principal), esse aplicativo justificará sua despesa no primeiro mês de uso.

Respondendo à pergunta que você fez, não, não é possível configurar uma senha padrão em um arquivo de configuração ssh.

Mas se, como você diz, é "porque às vezes eu me afasto do PC e, quando volto, digite uma senha e pressione Entero terminal CONNECTION CLOSED" , então por que não impedir o fechamento da sessão? O SSH pode manter as conexões ativas para você.

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

Obrigado, Arek pela inspiração ...

Em vez de executar outro processo do shell, esta é apenas uma função em execução no shell bash atual. Ele executa um único awkcomando para analisar o arquivo de configuração e descobrir se deve levar a senha de uma variável do shell ou da senha escrita em texto não criptografado no arquivo de configuração ssh (com problemas awkem que ao evalinvés de describedevido a problemas que usei describe).

Eu tentei várias maneiras de usar sshpassdiretamente em um ssharquivo de configuração usando o ProxyCommand, mas nada parecia funcionar como o esperado, exceto quando eu podia fazer login em uma caixa via RSA. Mas então eu precisava enviar uma senha para abrir meu diretório criptografado. No entanto, minha função abaixo parece funcionar para mim em todos os casos, mesmo 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)

Em seguida, uma ~/.ssh/configseção fica assim:

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

Se a #Passvar existir na seção de configuração, isso substituirá o #Password.
$MYPASS_ENVVARé a variável de ambiente que mantém sua senha.

Desfrutar!

A resposta de @BrunoPereira a esta pergunta mostra um método alternativo para conectar-se sem digitar explicitamente uma senha e evitar chaves ssh.

Você pode criar um script, um alias ou uma função ~/.bashrcpara executar rapidamente esse comando.

Obviamente, existem considerações de segurança que você deve levar em consideração com essa abordagem.

Aqui está minha variação elaborada da resposta de @ ArekBurdach. Oferece as seguintes extensões:

• o host pode estar em qualquer lugar da sshlinha de comando; ou seja, também suporta a ssh <args> <host> <commands>sintaxe
• não codifica o caminho para ssh
• análise mais robusta de ssh_config
• Bônus: invólucro para scp, também

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

Instalação

Defina aliases no seu ~/.bashrc:

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

Configuração

Com a IgnoreUnknowndiretiva, sshnão se queixa de uma Passworddiretiva recém-introduzida , portanto (em contraste com a resposta de @ ArekBurdach), podemos fazer com que isso pareça uma configuração "real". Se você não gosta disso, é trivial alterar o script novamente para o comentado.

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

Host foohost
    User baruser
    Password foobarpassword

Se você não tiver acesso direto ao par de chaves, poderá criptografar a senha na sua máquina local.

A maneira de fazer isso é criptografar sua senha usando a chave , além do ProxyCommand do @Eric Woodruff.

Uma maneira de combinar é usar pipe:

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

Onde

Host real-destination
    Hostname test.com
    User netmoon

Existe uma pequena variação de uma maneira descrita no blog sobre como usar, sshpass que pode ser encontrada aqui . Como você tem um arquivo de senha criptografada gpg (como isso é descrito no blog), você pode fazer algo assim:

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

e simplesmente salve esse comando como um alias no seu .bashrc.

Se você quiser fazer um túnel através dessa conexão, poderá fazer 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