linux - programas - automatización de sesión de telnet utilizando scripts bash

script linux ejemplos

Question

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

los scripts se ven así:

# 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 que estoy enfrentando aquí:

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

   Desde 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 líneas de código subsiguientes 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 para la actividad en la sesión de telnet en el sistema local. El redireccionamiento estándar que usé hace una copia en el sistema remoto (no quiero realizar una operación de copia para copiar el registro al sistema local). ¿Cómo puedo lograr esta funcionalidad?

Answer 1

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

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

Answer 2

Escribir un script de expect

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

Answer 3

Esto funcionó para mí ...

Intentaba automatizar múltiples inicios de sesión de telnet que requieren un nombre de usuario y contraseña. La sesión de telnet debe ejecutarse en segundo plano indefinidamente ya que guardo registros de diferentes servidores en mi máquina.

telnet.sh automatiza el inicio de sesión de telnet utilizando 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úrate de que no haya ninguna pantalla ejecutándose en el backgroud usando el comando ''screen -ls''.
2. Lee 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 conectar 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''.

Answer 4

Juegue con tcpdump o wireshark y vea 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 contiene líneas en la pila

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

Answer 5

Lo siguiente está funcionando para mí ... pon todas tus direcciones IP que quieras 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

Answer 6

Puede usar las secuencias de comandos expect instaladas de bash. El siguiente ejemplo muestra cómo hacer telnex en una placa integrada sin 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

Answer 7

Si bien sugiero utilizar también el uso esperado, para uso no interactivo, los comandos de shell normales pueden ser suficientes. Telnet acepta su comando en stdin, por lo que solo necesita conectar 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 un poco de tiempo para procesar las entradas o el telnet no toma con agrado el SIGHUP inicial. En estos casos, puede probar un breve descanso en la entrada :)

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

En cualquier caso, si se está haciendo interactivo o lo que sea, use expect .

Answer 8

Telnet se usa a menudo cuando aprende el protocolo HTTP. Solía ​​usar ese script como parte de mi 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 el nombre del script es get-page.sh y luego:

get-page.sh | telnet

le dará un documento html.

Espero que sea útil para alguien;)

Answer 9

Use ssh para ese propósito. Genere claves sin usar una contraseña y colóquela en .authorized_keys en la máquina remota. Cree la secuencia de comandos para que se ejecute de forma remota, cópiela en la otra máquina y luego simplemente ejecútela de forma remota con ssh.

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

Answer 10

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