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

Question

Estou usando o Ubuntu 11.10. Eu estou usando o ssh para conectar-se a muitos servidores diariamente, então eu coloco seus parâmetros em .ssh/config file; assim:

Host Home
User netmoon
Port 22
HostName test.com

Existe uma maneira de colocar senhas neste arquivo, para cada conexão? Então, quando o servidor pede senha, o terminal coloca o seu passe e envia para o servidor.

É porque às vezes eu fico longe do pc e quando eu volto e digito senha, e pressiono enter, o terminal disse CONEXÃO FECHADA.

• Eu não quero usar o par de chaves pública / privada.

Answer 1

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

Você poderia usar ssh-copy-id do pacote openssh-client ?

De man ssh-copy-id :

ssh-copy-id is a script that uses ssh to log into a remote machine and append the indicated identity file to that machine's ~/.ssh/authorized_keys file.

    

Answer 2

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

Edit: O que quero dizer é que você pode ter um script que, por um lado, usa expect para inserir a senha para você e, por outro lado, lê a senha para um determinado usuário e host de uma configuração Arquivo. 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: Como explicado, o script python precisaria ser muito mais complexo para lidar com todos os possíveis erros e questionar as mensagens do ssh e todos os URLs possíveis (no exemplo, assume-se que será algo como user@host , mas a parte do usuário não é usada na maioria das vezes), mas a ideia básica ainda seria a mesma. Registando o arquivo de configuração, você pode usar um arquivo de configuração diferente ou usar .ssh/config e escrever seu próprio código para analisar esse arquivo e obter a senha para um determinado usuário e host.

    

Answer 3

Existe também o programa sshpass para isso. Como usar: sshpass -p MyPa55word ssh [email protected]

    

Answer 4

Não. Isso não é possível, estou com medo.

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

    

Answer 5

Como sobre 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ê também pode usar ssh -W em vez de nc :

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

    

Answer 6

Você pode criar uma substituição simples de script ssh em / usr / local / bin:

#!/bin/bash

host=$1
password='awk "/#Password/ && inhost { print \\ } /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

    

Answer 7

Eu uso um aplicativo da VanDyke Software chamado SecureCRT .

link

Não é grátis, mas tem preços muito razoáveis. Eu tenho usado por anos (rodando no Windows, ou usando Wine) para acesso remoto, emulação de terminal e gerenciamento de rede (dispersa). Eles finalmente lançaram uma versão nativa do Linux no início de 2011.

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

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

Eu 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 fazendo muito acesso remoto (parte de sua função principal), esse aplicativo justificará sua despesa no primeiro mês de uso.

    

Answer 8

Respondendo a pergunta que você pediu, não, não é possível configurar a senha padrão no arquivo de configuração ssh.

Mas se de fato, como você diz " É porque às vezes eu fico longe do pc e quando eu volto e digito senha, e pressiono enter, terminal disse CONEXÃO FECHADA. ", então porque não impedir o fechamento da sessão em vez disso? O SSH pode manter conexões vivas para você.

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

    

Answer 9

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

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

Obviamente, há considerações de segurança que você deve levar em conta nessa abordagem.

    

Answer 10

Obrigado Arek pela inspiração ...

Em vez de executar outro processo de shell, esta é apenas uma função em execução no shell bash atual. Ele roda o awk único para analisar o arquivo de configuração e descobrir se deve pegar a senha de uma variável do shell ou da senha escrita no arquivo de configuração ssh (com o awk em um eval ao invés de descrever devido a problemas que eu usei usando describe). Eu tentei muitas maneiras de usar sshpass diretamente em um arquivo de configuração ssh usando ProxyCommand, mas nada parecia funcionar como esperado, exceto quando eu poderia fazer o login em uma caixa via rsa, mas 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 o Cygwin.

# In your .bash_profile
function ssh(){
    host=$1;
    unset PASSWORD
    unset PASSVAR
    eval $(awk "/#[Pp]assvar / && inhost { printf \"PASSVAR=%s\",\; exit 1 } /#[Pp]assword / && inhost { printf \"PASSWORD=%s\",\; } /^[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)

Então, uma seção ~/.ssh/config tem esta aparência:

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

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

Aproveite!

    

Answer 11

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

• o host pode estar em qualquer lugar na linha de comando ssh ; isto é, também suporta a sintaxe ssh <args> <host> <commands>
• não codifica o caminho para ssh
• análise mais robusta de ssh_config
• Bônus: wrapper 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 diretiva IgnoreUnknown , ssh não reclama de uma diretiva Password recém-introduzida, então (em contraste com a resposta do @ ArekBurdach), podemos fazer isso aparecer como uma configuração "real". Se você não gosta disso, é trivial mudar o script de volta para o comentário.

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

Host foohost
    User baruser
    Password foobarpassword

    

Answer 12

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

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

Uma maneira de combinar é usar o 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