बैश स्क्रिप्ट का उपयोग करके टेलनेट सत्र को स्वचालित करना

Question 1

मैं बैश स्क्रिप्ट का उपयोग करके कुछ टेलनेट से संबंधित कार्यों को स्वचालित करने पर काम कर रहा हूं। एक बार स्वचालित होने पर टेलनेट के साथ उपयोगकर्ता की कोई बातचीत नहीं होगी। (यह पूरी तरह से स्वचालित होगा)

स्क्रिप्ट कुछ इस तरह दिखती हैं:

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

यहाँ मैं 2 समस्याओं का सामना कर रहा हूँ:

रिमोट सिस्टम पर स्क्रिप्ट (मानव अंतःक्रिया के बिना) को कैसे निष्पादित किया जाए?

कुछ परीक्षण कोड के साथ अपने अनुभव से, मैं यह पता लगाने में सक्षम था कि जब टेलनेट 10.1.1.1 निष्पादित किया जाता है, तो टेलनेट एक इंटरैक्टिव सत्र में जाता है और स्क्रिप्ट में कोड की बाद की लाइनें स्थानीय सिस्टम पर निष्पादित होती हैं। मैं स्थानीय के बजाय रिमोट सिस्टम पर कोड की लाइनें कैसे चला सकता हूं?
मैं स्थानीय प्रणाली पर टेलनेट सत्र में गतिविधि के लिए एक लॉग फ़ाइल प्राप्त करने में असमर्थ हूं। मेरे द्वारा उपयोग किया जाने वाला स्टडआउट पुनर्निर्देशन रिमोट सिस्टम पर एक प्रतिलिपि बनाता है (मैं स्थानीय सिस्टम में लॉग को कॉपी करने के लिए कॉपी ऑपरेशन नहीं करना चाहता)। मैं इस कार्यक्षमता को कैसे प्राप्त कर सकता हूं?

Question 2

एक expectस्क्रिप्ट लिखें ।

यहाँ एक उदाहरण है:

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

चलाने के लिए:

./myscript.expect name user password

Question 3

जबकि मैं सुझाव देता हूं कि गैर-संवादात्मक उपयोग के लिए सामान्य शेल कमांड पर्याप्त हो सकता है, उम्मीद का उपयोग करना। टेलनेट स्टड पर अपनी कमांड को स्वीकार करता है, इसलिए आपको बस इसमें कमांड को पाइप या लिखने की जरूरत है:

telnet 10.1.1.1 <<EOF
remotecommand 1
remotecommand 2
EOF

(संपादित करें: टिप्पणियों से देखते हुए, दूरस्थ कमांड को इनपुट्स को संसाधित करने के लिए कुछ समय की आवश्यकता होती है या शुरुआती SIGHUP को टेलनेट द्वारा इनायत से नहीं लिया जाता है। इन मामलों में, आप इनपुट पर एक छोटी नींद की कोशिश कर सकते हैं :)

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

किसी भी मामले में, अगर यह इंटरैक्टिव या कुछ भी हो रहा है, तो उपयोग करें expect।

Question 4

जब आप HTTP प्रोटोकॉल सीखते हैं तो टेलनेट का उपयोग अक्सर किया जाता है। मैं उस स्क्रिप्ट को अपने वेब-स्क्रैपर के एक भाग के रूप में उपयोग करता था:

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

मान लीजिए कि स्क्रिप्ट का नाम get-page.sh है:

get-page.sh | telnet

आपको एक HTML दस्तावेज़ देगा।

आशा है कि यह किसी के लिए उपयोगी होगा;)

Question 5

यह मेरे लिए काम किया ..

मैं कई टेलनेट लॉगिन को स्वचालित करने की कोशिश कर रहा था, जिसके लिए उपयोगकर्ता नाम और पासवर्ड की आवश्यकता होती है। टेलनेट सत्र को पृष्ठभूमि में अनिश्चित काल तक चलाने की आवश्यकता है क्योंकि मैं विभिन्न सर्वरों से लॉग को अपनी मशीन में सहेज रहा हूं।

telnet.sh 'उम्मीद' कमांड का उपयोग करके टेलनेट लॉगिन को स्वचालित करता है। अधिक जानकारी यहां पाई जा सकती है: 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 का उपयोग telnet.sh चलाकर प्रत्येक टेलनेट सत्र के लिए एक पृष्ठभूमि प्रक्रिया बनाने के लिए किया जाता है। अधिक जानकारी कोड के टिप्पणी अनुभाग में पाई जा सकती है।

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

सुनिश्चित करें कि कमांड 'स्क्रीन-पर्ल' का उपयोग करके बैकग्राउड में कोई स्क्रीन नहीं चल रही है।
स्क्रीन और इसके विकल्पों के बारे में अधिक पढ़ने के लिए http://www.gnu.org/software/screen/manual/screen.html#Stuff पढ़ें ।
'-X' विकल्प के माध्यम से कमांड भेजने के लिए एक विशिष्ट विंडो के लिए नमूना_ script.sh preselects और reattaches में '-p' विकल्प अन्यथा आपको 'कोई स्क्रीन सत्र नहीं मिला' त्रुटि मिलती है।

Question 6

आप उम्मीद की स्क्रिप्ट का उपयोग कर सकते हैं bash। नीचे दिए गए उदाहरण से पता चलता है कि बिना पासवर्ड वाला एक एम्बेडेड बोर्ड में टेलनेक्स कैसे

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

Question 7

निम्नलिखित मेरे लिए काम कर रहा है ... अपने सभी IP को IP_sheet.txt में टेलनेट करना चाहते हैं

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

Question 8

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

Question 9

उस प्रयोजन के लिए ssh का उपयोग करें। पासवर्ड का उपयोग किए बिना कुंजियाँ बनाएं और इसे दूरस्थ मशीन पर .authorized_keys पर रखें। दूरस्थ रूप से चलाने के लिए स्क्रिप्ट बनाएं, इसे दूसरी मशीन पर कॉपी करें और फिर इसे ssh का उपयोग करके दूरस्थ रूप से चलाएं।

मैंने एक बड़ी सफलता के साथ कई बार इस दृष्टिकोण का उपयोग किया। यह भी ध्यान दें कि यह टेलनेट की तुलना में बहुत अधिक सुरक्षित है।

Question 10

यहां बताया गया है कि बैश शेल / अपेक्षा में टेलनेट का उपयोग कैसे किया जाता है

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

Question 11

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

Question 12

के साथ खेलते हैं tcpdumpयाwireshark देखें कि सर्वर पर क्या कमांड भेजे जाते हैं

इसे इस्तेमाल करे

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

कुछ सर्वर को पासवर्ड के साथ देरी की आवश्यकता होती है क्योंकि यह स्टैक पर लाइनें नहीं रखता है

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