automatizando a session de telnet usando scripts bash

Eu estou trabalhando na automação de algumas tarefas relacionadas ao telnet, usando scripts Bash. Uma vez automatizado, não haverá interação do usuário com o telnet. (isto é, será totalmente automatizado)

os scripts são algo como isto:

# execute some commands on the local system # access a remote system with an IP address: 10.1.1.1 (for example) telnet 10.1.1.1 # execute some commands on the remote system # log all the activity (in a file) on the Local system # exit telnet # continue on with executing the rest of the script. 

Existem 2 problemas que estou enfrentando aqui:

  1. Como executar os comandos no sistema remoto a partir do script (sem interação humana)?

    Pela minha experiência com alguns códigos de teste, eu pude deduzir que quando o telnet 10.1.1.1 é executado, o telnet entra em uma session interativa e as linhas subseqüentes do código no script são executadas no sistema local. Como posso executar as linhas de código no sistema remoto em vez do local?

  2. Não consigo obter um arquivo de log para a atividade na session de telnet no sistema local. O redirecionamento padrão usado faz uma cópia no sistema remoto (não desejo executar uma operação de cópia para copiar o log para o sistema local). Como posso conseguir essa funcionalidade?

Escreva um roteiro expect .

Aqui está um exemplo:

 #!/usr/bin/expect #If it all goes pear shaped the script will timeout after 20 seconds. set timeout 20 #First argument is assigned to the variable name set name [lindex $argv 0] #Second argument is assigned to the variable user set user [lindex $argv 1] #Third argument is assigned to the variable password set password [lindex $argv 2] #This spawns the telnet program and connects it to the variable name spawn telnet $name #The script expects login expect "login:" #The script sends the user variable send "$user " #The script expects Password expect "Password:" #The script sends the password variable send "$password " #This hands control of the keyboard over two you (Nice expect feature!) interact 

Embora eu sugira usar o recurso também, para uso não interativo, os comandos normais do shell podem ser suficientes. O Telnet aceita seu comando no stdin, então você só precisa canalizar ou escrever os comandos nele:

 telnet 10.1.1.1 < 

(Edit: A julgar pelos comentários, o comando remoto precisa de algum tempo para processar as inputs ou o início SIGHUP não é tomado graciosamente pelo telnet. Nestes casos, você pode tentar um breve sono na input 🙂

 { echo "remotecommand 1"; echo "remotecommand 2"; sleep 1; } | telnet 10.1.1.1 

Em qualquer caso, se está ficando interativo ou qualquer coisa, use expect .

O Telnet é freqüentemente usado quando você aprende o protocolo HTTP. Eu costumava usar esse script como parte do meu web-scraper:

 echo "open www.example.com 80" sleep 2 echo "GET /index.html HTTP/1.1" echo "Host: www.example.com" echo echo sleep 2 

digamos que o nome do script seja get-page.sh então:

 get-page.sh | telnet 

vai te dar um documento html.

Espero que seja útil para alguém;)

Isso funcionou para mim ..

Eu estava tentando automatizar vários logins telnet que exigem um nome de usuário e senha. A session de telnet precisa ser executada indefinidamente em segundo plano, pois estou salvando logs de servidores diferentes na minha máquina.

O telnet.sh automatiza o login do telnet usando o comando ‘esperar’. Mais informações podem ser encontradas aqui: http://osix.net/modules/article/?id=30

telnet.sh

 #!/usr/bin/expect set timeout 20 set hostName [lindex $argv 0] set userName [lindex $argv 1] set password [lindex $argv 2] spawn telnet $hostName expect "User Access Verification" expect "Username:" send "$userName\r" expect "Password:" send "$password\r"; interact 

sample_script.sh é usado para criar um processo em segundo plano para cada uma das sessões de telnet executando telnet.sh. Mais informações podem ser encontradas na seção de comentários do código.

sample_script.sh

 #!/bin/bash #start screen in detached mode with session-name 'default_session' screen -dmS default_session -t screen_name #save the generated logs in a log file 'abc.log' screen -S default_session -p screen_name -X stuff "script -f /tmp/abc.log $(printf \\r)" #start the telnet session and generate logs screen -S default_session -p screen_name -X stuff "expect telnet.sh hostname username password $(printf \\r)" 
  1. Certifique-se de que não haja canvas sendo executada no backgroud usando o comando ‘screen -ls’.
  2. Leia http://www.gnu.org/software/screen/manual/screen.html#Stuff para ler mais sobre a canvas e suas opções.
  3. A opção ‘-p’ em sample_script.sh pré-seleciona e reconecta a uma janela específica para enviar um comando através da opção ‘-X’, caso contrário, você recebe um erro ‘Nenhuma session de canvas encontrada’.

Você pode usar esperar scripts instaed de bash. Abaixo exemplo mostra como telexar em uma placa embutida sem senha

 #!/usr/bin/expect set ip "" spawn "/bin/bash" send "telnet $ip\r" expect "'^]'." send "\r" expect "#" sleep 2 send "ls\r" expect "#" sleep 2 send -- "^]\r" expect "telnet>" send "quit\r" expect eof 

Use o ssh para esse propósito. Gere chaves sem usar uma senha e coloque-as em .authorized_keys na máquina remota. Crie o script para ser executado remotamente, copie-o para a outra máquina e depois execute-o remotamente usando o ssh.

Eu usei essa abordagem muitas vezes com um grande sucesso. Note também que é muito mais seguro que o telnet.

 #!/bin/bash ping_count="4" avg_max_limit="1500" router="sagemcom-fast-2804-v2" adress="192.168.1.1" user="admin" pass="admin" VAR=$( expect -c " set timeout 3 spawn telnet "$adress" expect \"Login:\" send \"$user\n\" expect \"Password:\" send \"$pass\n\" expect \"commands.\" send \"ping ya.ru -c $ping_count\n\" set timeout 9 expect \"transmitted\" send \"exit\" ") count_ping=$(echo "$VAR" | grep packets | cut -c 1) avg_ms=$(echo "$VAR" | grep round-trip | cut -d '/' -f 4 | cut -d '.' -f 1) echo "1_____ping___$count_ping

____$avg_ms” echo “$VAR”

Aqui está como usar o telnet no shell bash / esperar

 #!/usr/bin/expect # just do a chmod 755 one the script # ./YOUR_SCRIPT_NAME.sh $YOUHOST $PORT # if you get "Escape character is '^]'" as the output it means got connected otherwise it has failed set ip [lindex $argv 0] set port [lindex $argv 1] set timeout 5 spawn telnet $ip $port expect "'^]'." 

A seguir está trabalhando para mim … colocar todos os seus IPs que você deseja telnet em IP_sheet.txt

 while true read a do { sleep 3 echo df -kh sleep 3 echo exit } | telnet $a done 

Jogue com o tcpdump ou wireshark e veja quais comandos são enviados para o próprio servidor

Tente isso

 printf (printf "$username\r\n$password\r\nwhoami\r\nexit\r\n") | ncat $target 23 

Alguns servidores exigem um atraso com a senha, pois ela não contém linhas na pilha

 printf (printf "$username\r\n";sleep 1;printf "$password\r\nwhoami\r\nexit\r\n") | ncat $target 23**