automatización de sesión de telnet utilizando scripts bash

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?

    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 

    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 <  

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

    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;)

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

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

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

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

    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 

    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 stack

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