automatyzacja sesji telnet za pomocą skryptów bash

Chociaż sugerowałbym również użycie expect, do nieinteraktywnego użycia zwykłe polecenia powłoki mogą wystarczyć. Telnet akceptuje swoje polecenia na stdin, więc musisz je tylko przesłać lub zapisać do niego:

telnet 10.1.1.1 <<EOF
remotecommand 1
remotecommand 2
EOF

(Edit: sądząc po komentarzach, polecenie zdalne potrzebuje trochę czasu, aby przetworzyć dane wejściowe lub wczesne SIGHUP nie zostanie odebrane z wdziękiem przez telnet. W takich przypadkach możesz spróbować krótkiego snu na wejściu:)

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

W każdym razie, jeśli staje się interaktywny lub cokolwiek, użyj expect.

Telnet jest często używany, gdy uczysz się protokołu HTTP. Kiedyś używałem tego skryptu jako części mojego skrobaka internetowego:

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

Powiedzmy, że nazwa skryptu to get-page.sh wtedy:

get-page.sh | telnet

Da ci dokument html.

Mam nadzieję, że komuś się przyda;)

To mi pomogło..

Próbowałem zautomatyzować wiele logowań telnet, które wymagają nazwy użytkownika i hasła. Sesja telnet musi działać w tle na czas nieokreślony, ponieważ zapisuję dzienniki z różnych serwerów na moim komputerze.

Telnet.sh automatyzuje logowanie telnet za pomocą polecenia "expect". Więcej informacji można znaleźć tutaj: 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 służy do tworzenia proces w tle dla każdej z sesji telnet poprzez uruchomienie telnet.sh. więcej informacji można znaleźć w sekcji komentarze Kodeksu.

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. upewnij się, że ekran nie działa w tle, używając polecenie 'screen-ls'.
2. Czytaj http://www.gnu.org/software/screen/manual/screen.html#Stuff aby przeczytać więcej o ekranie i jego opcjach.
3. '-p' opcja w sample_script.sh preselekcja i ponowne podłączenie do konkretnego okna, aby wysłać polecenie poprzez opcja '- X 'w przeciwnym razie pojawi się błąd 'nie znaleziono sesji ekranu'.

Możesz używać skryptów expect instaed bash. Poniższy przykład pokazuje, jak telnex do wbudowanej tablicy bez hasł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

Użyj w tym celu ssh. Wygeneruj klucze bez użycia hasła i umieść je .authorized_keys na zdalnej maszynie. Utwórz skrypt, który ma być uruchamiany zdalnie, skopiuj go na inną maszynę, a następnie uruchom go zdalnie za pomocą ssh.

Stosowałem to podejście wiele razy z dużym sukcesem. Należy również pamiętać, że jest znacznie bezpieczniejszy niż 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"

Oto jak używać telnetu w powłoce bash / 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 "'^]'."

Śledzenie mnie działa... umieść wszystkie swoje adresy IP, które chcesz połączyć z siecią w IP_sheet.txt

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

Zagraj tcpdump lub wireshark i zobacz jakie polecenia są wysyłane na sam Serwer

Spróbuj tego

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

Niektóre serwery wymagają opóźnienia z hasłem, ponieważ nie przechowuje linii na stosie

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