automatizar la sesión de telnet usando scripts bash

Estoy trabajando en la automatización de algunas tareas relacionadas con telnet, usando scripts Bash. Una vez automatizado, no habrá interacción del usuario con telnet. (es decir, estará totalmente automatizado)

los scripts se parecen a esto:

# 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.

Hay 2 problemas a los que me enfrento aquí:

1. ¿Cómo ejecutar los comandos en el sistema remoto desde el script (sin interacción humana)?

   De mi experiencia con algunos códigos de prueba, pude deducir que cuando se ejecuta telnet 10.1.1.1 , telnet entra en una sesión interactiva y las siguientes líneas de código en el script se ejecutan en el sistema local. ¿Cómo puedo ejecutar las líneas de código en el sistema remoto en lugar del local?

2. No puedo obtener un archivo de registro de la actividad en la sesión de telnet en el sistema local. La redirección de stdout que utilicé hace una copia en el sistema remoto (no quiero realizar una operación de copia para copiar el registro en el sistema local). ¿Cómo puedo lograr esta funcionalidad?

Escribe un expectguión.

Aquí hay un ejemplo:

#!/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 to you (Nice expect feature!)
interact

Correr:

./myscript.expect name user password

Si bien sugeriría usar esperar también, para un uso no interactivo, los comandos de shell normales podrían ser suficientes. Telnet acepta su comando en stdin, por lo que solo necesita canalizar o escribir los comandos en él:

telnet 10.1.1.1 <<EOF
remotecommand 1
remotecommand 2
EOF

(Editar: a juzgar por los comentarios, el comando remoto necesita algo de tiempo para procesar las entradas o el SIGHUP temprano no es tomado con elegancia por telnet. En estos casos, puede intentar una breve suspensión en la entrada :)

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

En cualquier caso, si se está volviendo interactivo o algo así, use expect.

Telnet se usa a menudo cuando aprende el protocolo HTTP. Solía ​​usar ese script como parte de mi raspador web:

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 el nombre del script es get-page.sh y luego:

get-page.sh | telnet

le dará un documento html.

Espero que sea de ayuda para alguien;)

Esto funcionó para mí ...

Estaba intentando automatizar varios inicios de sesión de telnet que requieren un nombre de usuario y una contraseña. La sesión de telnet debe ejecutarse en segundo plano de forma indefinida, ya que estoy guardando registros de diferentes servidores en mi máquina.

telnet.sh automatiza el inicio de sesión de telnet usando el comando 'esperar'. Puede encontrar más información aquí: 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 se utiliza para crear un proceso en segundo plano para cada una de las sesiones de telnet ejecutando telnet.sh. Se puede encontrar más información en la sección de comentarios del 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. Asegúrese de que no se esté ejecutando ninguna pantalla en el fondo mediante el comando 'screen -ls'.
2. Lea http://www.gnu.org/software/screen/manual/screen.html#Stuff para leer más sobre la pantalla y sus opciones.
3. La opción '-p' en sample_script.sh preselecciona y vuelve a adjuntar a una ventana específica para enviar un comando a través de la opción '-X'; de lo contrario, aparece el error 'No se encontró sesión de pantalla'.

Puede utilizar los scripts de espera instalados en bash. El siguiente ejemplo muestra cómo hacer telnex en una placa incorporada que no tiene contraseña

#!/usr/bin/expect

set ip "<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

Lo siguiente está funcionando para mí ... coloque todas sus IP que desea telnet en IP_sheet.txt

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

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

Utilice ssh para ese propósito. Genere claves sin usar una contraseña y colóquelas en .authorized_keys en la máquina remota. Cree el script para ejecutarlo de forma remota, cópielo en la otra máquina y luego ejecútelo de forma remota usando ssh.

Usé este enfoque muchas veces con gran éxito. También tenga en cuenta que es mucho más seguro que telnet.

Aquí es cómo usar telnet en bash shell / espera

#!/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 "'^]'."

Script para obtener la versión de los servidores CISCO:

#!/bin/sh

servers='
192.168.34.1
192.168.34.3
192.168.34.2
192.168.34.3
'
user='cisco_login'
pass='cisco_password'

show_version() {
host=$1
expect << EOF
set timeout 20
set host $host
set user $user
set pass $pass
spawn telnet $host
expect "Username:"
send "$user\r"
expect "Password:"
send "$pass\r"
expect -re ".*#"
send "show version\r"
expect -re ".*-More-.*"
send " "
expect -re ".*#"
send "exit\r"
EOF
}

for ip in $servers; do
  echo '---------------------------------------------'
  echo "$ip"
  show_version $ip | grep -A3 'SW Version'
done

Juega con tcpdumpo wiresharky mira qué comandos se envían al servidor.

Prueba esto

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

Algunos servidores requieren un retraso con la contraseña ya que no retiene líneas en la pila

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