แฅแกแแแแก แแแแแแ แแแก แฎแจแแ แแ แแฌแงแแแแแแ แแแ แแแแฃแแ แคแ แแแแแแขแแแแก แแแแแ แแแ/แแแกแแ แแแแแแแขแแแแ แแแแกแแแจแ. แแฅแแแ แฉแแแฃแแแแ แแ แฃแแแ แแแแแแแแ แแ แ แแแแแแแแ แแแ แแแแขแ แ: แแแแฎแแแ แแแแแก แกแแฎแแแ/แแแ แแแ แแ แกแฎแแ. แกแแ แแแขแแแแก แแแแแงแแแแแ แกแแจแฃแแแแแแก แแแซแแแแ แแแแฉแฅแแ แแ แแก แแ แแชแแกแ. แแแแ แแ แกแแ แแแขแแก แแแฌแแ แแกแ แแ แกแแ แแแขแแก แจแแกแ แฃแแแแแก แฃแคแ แ แแแแแแแ แแ แ แฃแแแ แแแกแญแแ แแแก, แแแแ แ แฎแแแแ แแแแคแแแฃแ แแชแแแก, แฌแแแแแฆแแแแ แจแแแแฎแแแแแจแ แกแแ แแแขแแแ แแแแแฃแกแแแแแแ แแ.
แ แแกแแแแก แแ แแก แแก แกแขแแขแแ? แแก แกแขแแขแแ แแ แแก แกแฌแ แแคแ แแแฌแงแแแแก แกแแ แแแแแ แแ แแแแแแ แแกแแฎแแแก แฅแกแแแแก แแแแแแ แแแแก แแ แแแก แแแแแแแแก แแ แแแแ แแแฌแงแแแแแแแแแ แแฆแญแฃแ แแแแแแแก (แแ แแ แแแแแแแแแก) แแแงแแแแแแกแแก. แแงแแแแแก SecureCRT แแ แแแ แแแฃแ แฃแแ แฃแแแแแงแแคแแก แแ แฉแแจแแแแแฃแ แกแแ แแแขแแก แจแแกแ แฃแแแแแก แคแฃแแฅแชแแแก.
แแแคแแ แแแชแแแก
แจแแกแแแแแ แแแ แขแแแ แกแแ แแแขแแแแก แจแแฅแแแ แกแแ แแแขแแแแก แแแจแแแแ SecureCRT-แแ แฎแแแแ แแแจแแแแ SecureCRT แแแแแฃแแแ แแแขแแแแขแฃแ แ แแแฌแงแแแ แแแแจแแ แแก แจแแแแแ (แจแแกแแแแก แกแแ แแแขแ) แแแขแแแแขแฃแ แ แจแแกแแแ แกแแ แแแขแแก แแแแแงแแแแแแก แแแ แแจแ แฎแแแแ แฉแแ แแแ SecureCRT-แจแ แฆแแแแแแ (แฆแแแแแ แฏแแ แแ แแ แแก แจแแฅแแแแแ แแ แแแแแขแแแฃแแ SecureCRT-แจแ)
แแแ แขแแแ แแ แแแฌแแแแแ แกแแ แแแขแแแแก แแแแแงแแแแแแก แแแแแแแแแแ. (แแ แแฅแขแแแ แ แแแแฃแ แ แชแฎแแแ แแแแแแ.) แแแแฎแแแ แแแแแกแแแ แแแแแชแแแแแแก แแแแฎแแแแ แแแแแแแฃแ แ แคแแแฏแ แแก แแแแแงแแแแแแ FTP แแแแแ แแแ แฅแกแแแฃแ แแฆแญแฃแ แแแแแแแจแ. แแแแฎแแแ แแแแแก แกแแฎแแแแก/แแแ แแแแก แจแแงแแแแ แกแแ แแแขแแก แแแแแงแแแแแแ แกแแ แแแขแ แกแแ แแแขแแก แจแแกแ แฃแแแแแก แแ แแก แแแแแชแแแแแแก แฃแจแฃแแแแ แแแแแขแแแแก แจแแกแแซแแแแแแแแ
แแแกแแแแ แแแแแงแแแแแฃแแ แฌแงแแ แแแแ แแแแแ แแ 1: แกแแ แแแขแแแแก แแแแฃแจแ. แแ แซแแแ แกแแ แแแขแ IP แแแกแแแแ แแแก แแแงแแแแแแ, แฐแแกแขแแก แกแแฎแแแแ (IP แแแกแแแแ แแ แแ แฐแแกแขแแก แกแแฎแแแ แแแแแฎแแแแแ แกแแ แแแขแแก แจแแกแ แฃแแแแแกแแก) แแ แแแแแแ แแ แกแแฌแงแแกแ แขแแฅแแแแแก แแแ แแแแขแ แแ แแแแแ แแจแแก แแแงแแแแแ ssh-แกแแแแก
SecureCRT-แแก แจแแกแแฎแแ
แจแแกแแแแแ
SecureCRT แแ แแแ แแแแก แแฅแแก แฉแแจแแแแแฃแแ แกแแ แแแขแแก แจแแกแ แฃแแแแแก แแแฅแแแแแแ. แ แแกแแแแก แแ แแก แขแแ แแแแแแแก แกแแ แแแขแแแ?
- แแแขแแแแขแฃแ แ I/O แแ แแแแแแแแฃแ แ I/O แแแแแแแชแแ.
- แแแแฉแฅแแ แแ แ แฃแขแแแฃแแ แแแแแแแแแแแก แจแแกแ แฃแแแแ - แจแแแแชแแ แแ แแแฃแแแแ แแฆแญแฃแ แแแแแแแก แแแ แแแแขแ แแแก แจแแ แแก. (แแ แคแแฅแขแ แจแแแชแแ แแแฃแแ แแแฃแแแแ, แ แแแแแแแช แแแแแฌแแแฃแแแ แแแแแ แแแแ แแขแฃแ แแแ แแกแแแก/แฌแแ แกแฃแแ แแแฅแแแแแแแแแก แจแแกแ แฃแแแแแก แแ แแแ, 3 แแ แแแขแ แแ แซแแแแแแก แคแ แแแแแแขแแ, แ แแแแแแแช แแแแแงแแแแแฃแแ แแฅแแแแ แแแแ แแขแฃแ แแแ.)
แแก แแแแฃแแแแขแ แแแแชแแแก แแแแชแแแแแก:
- แแแ แขแแแ แกแแ แแแขแแแแก แจแแฅแแแ.
- แกแแ แแแขแแแแก แแแจแแแแ SecureCRT-แแ.
- แแแ แขแแแ แแ แแแฌแแแแแ แกแแ แแแขแแแแก แแแแแงแแแแแแก แแแแแแแแแแ. (แแ แแฅแขแแแ แ แแแแฃแ แ แชแฎแแแ แแแแแแ.)
แแแ แขแแแ แกแแ แแแขแแแแก แจแแฅแแแ.
แฃแแแ แขแแแแกแ แกแแ แแแขแแแ แแงแแแแแก แแฎแแแแ แแ แแ แซแแแแแแก, Send แแ WaitForString. แแก แคแฃแแฅแชแแ แกแแแแแ แแกแแ แจแแกแ แฃแแแแฃแแ แแแแชแแแแแแก 90% (แแ แแแขแ).
แกแแ แแแขแแแก แจแแฃแซแแแแ แแแฃแจแแแ Python, JS, VBS (Visual Basic), Perl แแ แ.แจ.
Python
# $language = "Python"
# $interface = "1.0"
def main():
crt.Screen.Synchronous = True
crt.Screen.Send("r")
crt.Screen.WaitForString("name")
crt.Screen.Send("adminr")
crt.Screen.WaitForString("Password:")
crt.Screen.Send("Password")
crt.Screen.Synchronous = False
main()
แฉแแแฃแแแแ แแ แคแแแแ แแแคแแ แแแแแแ "*.py"
VBS
# $language = "VBScript"
# $interface = "1.0"
Sub Main
crt.Screen.Synchronous = True
crt.Screen.Send vbcr
crt.Screen.WaitForString "name"
crt.Screen.Send "cisco" & vbcr
crt.Screen.WaitForString "assword"
crt.Screen.Send "cisco" & vbcr
crt.Screen.Synchronous = False
End Sub
แฉแแแฃแแแแ แแ แคแแแแ แแแคแแ แแแแแแ "*.vbs"
แจแแฅแแแแแ แกแแ แแแขแ แกแแ แแแขแแก แฉแแแแฌแแ แแก แแแแแงแแแแแแ.
แกแแจแฃแแแแแแก แแแซแแแแ แแแขแแแแขแแแแ แแ แกแแ แแแขแแก แแแฌแแ แแก แแ แแชแแกแ. แแฌแงแแ แกแชแแแแ แแก แฌแแ แแก. SecureCRT แฉแแฌแแ แก แแ แซแแแแแแแก แแ แจแแแแแแ แแแแ แแขแฃแ แฃแ แแแกแฃแฎแก แแ แแฉแแแแแแก แแแกแ แฃแแแแฃแ แกแแ แแแขแก แแฅแแแแแแแก.
แ. แแแแฌแงแแ แกแแ แแแขแแก แฌแแ แ:
SecureCRT แแแแแฃ => แกแแ แแแขแ => แฉแแฌแแ แแก แกแแ แแแขแแก แแแฌแงแแแ
แ. แจแแแกแ แฃแแแ แแแฅแแแแแแแแ แแแแกแแแแแ (แจแแแกแ แฃแแแ แแแแคแแแฃแ แแชแแแก แแแแแฏแแแ CLI-แจแ).
แ. แแแแกแ แฃแแแ แกแชแแแแ แแก แฌแแ แ:
SecureCRT แแแแแฃ => แกแแ แแแขแ => แกแแ แแแขแแก แฉแแฌแแ แแก แจแแฌแงแแแขแโฆ
แจแแแแแฎแแ แกแแ แแแขแแก แคแแแแ.
แจแแกแ แฃแแแแฃแแ แแ แซแแแแแแแแก แแ แจแแแแฎแฃแแ แกแแ แแแขแแก แแแแแแแแ:
แกแแ แแแขแแแแก แแแจแแแแ SecureCRT-แแ.
แกแชแแแแ แแก แจแแฅแแแแก/แ แแแแฅแขแแ แแแแก แจแแแแแ แฉแแแแแ แแฃแแแแ แแแ แแแแฎแแ: แ แแแแ แแแแแแแงแแแแ แกแชแแแแ แ?
แแ แกแแแแแก แ แแแแแแแแ แแแ:
- แแแจแแแแ แฎแแแแ Script แแแแแฃแแแ
- แแแขแแแแขแฃแ แ แแแฌแงแแแ แแแแจแแ แแก แจแแแแแ (แจแแกแแแแก แกแแ แแแขแ)
- แแแขแแแแขแฃแ แ แจแแกแแแ แกแแ แแแขแแก แแแแแงแแแแแแก แแแ แแจแ
- แฎแแแแ แฉแแ แแแ SecureCRT-แจแ แฆแแแแแแ (แฆแแแแแ แฏแแ แแ แแ แแก แจแแฅแแแแแ แแ แแแแแขแแแฃแแ SecureCRT-แจแ)
แแแจแแแแ แฎแแแแ Script แแแแแฃแแแ
SecureCRT แแแแแฃ => แกแแ แแแขแ => แแแจแแแแโฆ
- แแแแ 10 แกแแ แแแขแ แแแแแฎแกแแแ แแแฃแแแ แแ แฎแแแแแกแแฌแแแแแแ แกแฌแ แแคแ แแแจแแแแแกแแแแก:
SecureCRT แแแแแฃ => แกแแ แแแขแ => 1 "แกแแ แแแขแแก แคแแแแแก แกแแฎแแแ"
SecureCRT แแแแแฃ => แกแแ แแแขแ => 2 "แกแแ แแแขแแก แคแแแแแก แกแแฎแแแ"
SecureCRT แแแแแฃ => แกแแ แแแขแ => 3 "แกแแ แแแขแแก แคแแแแแก แกแแฎแแแ"
SecureCRT แแแแแฃ => แกแแ แแแขแ => 4 "แกแแ แแแขแแก แคแแแแแก แกแแฎแแแ"
SecureCRT แแแแแฃ => แกแแ แแแขแ => 5 "แกแแ แแแขแแก แคแแแแแก แกแแฎแแแ"
แแแขแแแแขแฃแ แ แแแฌแงแแแ แแแแจแแ แแก แจแแแแแ (แจแแกแแแแก แกแแ แแแขแ)
แแแขแแแแขแฃแ แ แแฃแ แแแแแก แกแแ แแแขแแก แแแ แแแแขแ แแแ แแแแคแแแฃแ แแ แแแฃแแแ แจแแแแฎแฃแแ แกแแกแแแกแแแแก: แแแแจแแ แ => แจแแกแแแแก แแแฅแแแแแแแแ => แจแแกแแแแก แกแแ แแแขแ
แแแขแแแแขแฃแ แ แจแแกแแแ แกแแ แแแขแแก แแแแแงแแแแแแก แแแ แแจแ
แจแแกแแซแแแแแแแ แแแ แแแแก แแแแฎแแแ แแแแแก แกแแฎแแแแก แแแขแแแแขแฃแ แแ แจแแงแแแแ แกแแ แแแขแแก แแแฌแแ แแก แแแ แแจแ, แแฎแแแแ SecureCRT-แแก แฉแแจแแแแแฃแแ แคแฃแแฅแชแแแก แแแแแงแแแแแแ. แแแแจแแ แแก แแแ แแแแขแ แแแจแ "แแแแแแจแแ แแแ" => แจแแกแแแแก แแแฅแแแแแแแแ => แจแแกแแแแก แแแขแแแแขแแแแชแแ - แแฅแแแ แฃแแแ แจแแแแกแแ แ แแแแแแแแ แแแแแขแ - แ แแช แแแจแแแแก แฌแงแแแแแแก: "แแแกแแแแแแแแ แขแแฅแกแขแ" + "แแ แขแแฅแกแขแจแ แกแแแแแแแแแแก แแแแแแแแ" แจแแแซแแแแ แแแแ แ แแกแแแ แฌแงแแแแ แแงแแก. (แแแแแแแแ: 1-แแ แฌแงแแแแ แแแแแแแ แแแแฎแแแ แแแแแก แกแแฎแแแก, แแแแ แ แแแแแแแ แแแ แแแก, แแแกแแแ แแแแแแแ แแ แแแแแแแแ แแแฃแแ แ แแแแแแก แแแแฎแแแแแก, แแแแแฎแ แฌแงแแแแ แแ แแแแแแแแ แแแฃแแ แ แแแแแแก แแแ แแแก.)
แแแขแแแแขแฃแ แ แจแแกแแแแก แแแแแแแแ Cisco ASA-แแ:
แฎแแแแ แฉแแ แแแ SecureCRT-แจแ แฆแแแแแแ (แฆแแแแแ แฏแแ แแ แแ แแก แจแแฅแแแแแ แแ แแแแแขแแแฃแแ SecureCRT-แจแ)
SecureCRT-แจแ แจแแแแซแแแแ แกแแ แแแขแแก แแแแแญแแแ แฆแแแแแแ. แฆแแแแแ แแแแขแแแ แกแแแชแแแแฃแ แแ แแ แแแแแแ แจแแฅแแแแ แแแแแแก.
แ. แแแแแแแก แแแแแขแแแ แแแขแแ แคแแแกแจแ: SecureCRT แแแแแฃ => แแแฎแแ => แฆแแแแแแก แแแแ
แ. แแแแแแขแแ แฆแแแแแ แแแแแแแ แแ แแแแแแขแแ แกแแ แแแขแ. โ แแแแฌแแแแฃแแแ แฆแแแแแแ แแแ แฏแแแแ แฆแแแแแแ แแ แแแแขแแฅแกแขแฃแ แ แแแแแฃแแแ แแแ แฉแแแ โแแฎแแแ แฆแแแแแโฆโ.
แ. "Map Button" แแแแแแแฃแ แคแแแฏแแ แแจแ "Action" แแแแจแ แแแ แฉแแแ "Run Script" แแแฅแแแแแแ (แคแฃแแฅแชแแ).
แแแฃแแแแแ แฆแแแแแแก แฌแแ แฌแแ แ. แฆแแแแแแก แฎแแขแแก แคแแ แ. แแแแกแ แฃแแแ แแแ แแแแขแ แแแ Ok แแแฌแแแแฃแแแแแ.
แจแแแแจแแแ:
แแแแแแ แฆแแแแแแแแ แแ แแก แซแแแแแ แกแแกแแ แแแแแ แคแฃแแฅแชแแ.
1. แจแแกแแซแแแแแแแ แแแแแ แแขแฃแ แกแแกแแแแ แจแแกแแแแกแแก, แแแฃแแแแแ แ แแแแแ แแแแแแ แฃแแแ แแแแฎแกแแแก แแ แฉแแแแ แแแ แแแแฃแแแกแฎแแแแแ.
2. แจแแกแแซแแแแแแแ แกแขแแแแแ แขแฃแแ แแแฅแแแแแแแแแกแแแแก แฌแแแแกแฌแแ แแแแกแแแฆแแ แฃแแ แแแฅแแแแแแแแแก แแแงแแแแแ แแฆแญแฃแ แแแแแแแ: แจแแฃแก แแแ แกแแแก แฉแแแแแแ, แแแจแแแแแก แแแแคแแแฃแ แแชแแแก แฉแแแแแแ, แแแแคแแแฃแ แแชแแแก แจแแแแฎแแ.
แแ แชแแ แแ แกแแ แแแขแ แแ แแ แแก แแแแแแ แแแฃแแ แแ แฆแแแแแแแแ. แแฎแแแแ แกแแแแฅแแแแ แฎแแแ:
แแแ แแแแขแ แ - แแกแ, แ แแ แกแแกแแแแ แแแแแกแแแแกแแก, แฆแแแแแแแแ แกแแญแแ แ แแแแแแ แแฎแกแแแแ แกแแกแแแก แแแ แแแแขแ แแแจแ:
แแแแแแฃแ แแ, แ แแ แแแแฎแแแ แแแแแแ แจแแฅแแแแก แแแแแแแแฃแแแฃแ แ แกแแ แแแขแแแ Login-แแกแแแแก แแ แแแแแแแแแก แแแแแแแ แฎแจแแ แ แแ แซแแแแแแแแ แแแแงแแแแแแแกแแแแก.
แ แแแแกแแช แแแแญแแ แแ Go Cisco แฆแแแแแก, แแแแแแ แแแแแแแก Cisco แฆแแแแแแแแก แแแแแ.
แแแ แขแแแ แแ แแแฌแแแแแ แกแแ แแแขแแแแก แแแแแงแแแแแแก แแแแแแแแแแ. (แแ แแฅแขแแแ แ แแแแฃแ แ แชแฎแแแ แแแแแแ.)
แแแ แขแแแ แกแแ แแแขแแแ แกแแแแแ แแกแแ แแแแฅแแแก แงแแแแ แจแแแแฎแแแแแกแแแแก. แแแแ แแ แแ แแฎแแ แแแแญแแ แแ แกแชแแแแ แแก แชแแขแ แแแ แแฃแแแแ - แกแแแฃแจแแแก แแแฉแฅแแ แแแ. แแ แแแ แแฃแแแแแ แฃแแ แแแแ แแแแแฎแแแ แแแแแขแแแแแ แแแแแชแแแแแ แแแแฎแแแ แแแแแกแแแ แแแแแแแฃแ แคแแแฏแแ แแจแ.
แแแแฎแแแ แแแแแกแแแ แแแแแชแแแแแแก แแแแฎแแแแ แแแแแแแฃแ แ แคแแแฏแ แแก แแแแแงแแแแแแ
แแแแแชแแแแ แแแแฎแแแแแก แกแแ แแแขแจแ แแฅแแแแ 2. แแก แแ แแก แฐแแกแขแแก แกแแฎแแแ แแ IP แแแกแแแแ แแแก แแ-4 แแฅแขแแขแ. แแ แแแฅแแแแแแแก แจแแกแแกแ แฃแแแแแแ - แแแแแฃแแแ, แ แแแแ แแแแแแแแ แแก แแ แแแแแแ SecureCRT-แแก แแคแแชแแแแฃแ แแแแกแแแขแแ (vandyke). - แคแฃแแฅแชแแแแแ แแแแก แแฌแแแแแ แกแฌแ แแคแ.
crt.Screen.WaitForString("-Vlanif200]")
hostnamestr = crt.Dialog.Prompt("Enter hostname:", "hostname", "", False)
ipaddressstr = crt.Dialog.Prompt("Enter ip address:", "ip", "", False)
crt.Screen.Send("ip address 10.10.10.")
crt.Screen.Send(ipaddressstr)
crt.Screen.Send(" 23r")
crt.Screen.Send("quitr")
crt.Screen.Send("sysname ")
crt.Screen.Send(hostnamestr)
crt.Screen.Send("r")
แกแแ แแแขแแก แแก แแแฌแแแ แแแฎแแแแ แแแกแแแแซแแแก แกแแฎแแแก แแ แแแแ แแแก แแแแ แแฅแขแแขแแแแ. แแแแแแแแ แแงแ 15 แชแแแ แแฆแญแฃแ แแแแแแ. แแ แแแแแชแแแแแ แฌแแ แแแแแแแแแ แแงแ แชแฎแ แแแจแ, แจแแแแแ แแ แแแแแแแแแ แ แแแแจแแแแแแแแแ แชแฎแ แแแแแแ แแ แฉแแกแแแ แแแแแแแฃแ แคแแแฏแ แแแจแ. แจแแแแแแ แกแชแแแแ แ แแแแแฃแแแแแแแแ แแฃแจแแแแแ.
FTP แแแแแ แแแ แฅแกแแแฃแ แแฆแญแฃแ แแแแแแแจแ.
แแ แกแแ แแแขแแ แแแฃแจแแ แฉแแแ แแ แซแแแแแแก แคแแแฏแแ แ (แญแฃแ แแ) แแ แแแแแแแแ แ แแแแแชแแแแแ FTP-แแก แกแแจแฃแแแแแแ. แแแกแแกแ แฃแแก, แแแฎแฃแ แแ แกแฎแแแแ. แแแแกแแแแก แแแฃแแแแแแก แแแแแงแแแแแ แจแแฃแซแแแแแแแ, แ แแแแแ แแแแแ แแแแก แซแแแแแ แแแแ แแ แ แกแญแแ แแแแ แแ FTP แแฃแคแแ แจแ แแแแแชแแแแแ แแ แจแแแแแฎแแแ แแแแแแ แฎแแแ:
# $language = "Python"
# $interface = "1.0"
# Connect to a telnet server and automate the initial login sequence.
# Note that synchronous mode is enabled to prevent server output from
# potentially being missed.
def main():
crt.Screen.Synchronous = True
crt.Screen.Send("ftp 192.168.1.1r")
crt.Screen.WaitForString("Name")
crt.Screen.Send("adminr")
crt.Screen.WaitForString("Password:")
crt.Screen.Send("Passwordr")
crt.Screen.WaitForString("ftp")
crt.Screen.Send("binaryr")
crt.Screen.WaitForString("ftp")
crt.Screen.Send("put S5720LI-V200R011SPH016.patr")
crt.Screen.WaitForString("ftp")
crt.Screen.Send("quitr")
crt.Screen.Synchronous = False
main()
แแแแฎแแแ แแแแแก แกแแฎแแแแก/แแแ แแแแก แจแแงแแแแ แกแแ แแแขแแก แแแแแงแแแแแแ
แแ แ-แแ แ แแแแฎแแแ แแแแแก แฅแกแแแฃแ แแฆแญแฃแ แแแแแแแแ แฌแแแแแ แแแ แแแแแ แแแแฎแฃแ แ. แแแฌแงแแแแแแแแจแ แจแแกแแแ แจแแกแแซแแแแแแ แแงแ แฏแแ แแแแฃแแแกแฎแแแ แแแ แแแญแแกแแแ แแแแแแจแแ แแแแ, แจแแแแแ แแ แแแกแแแ แแแแแแจแแ แแแฃแ แแฆแญแฃแ แแแแแแแกแแแ. แแแกแแแแแจแแ แแแแแ แแแแแงแแแแแฃแแ แแงแ ssh แแแแแแขแ แฉแแจแแแแแฃแแ IOS/แขแแฅแแแแแก แแ แแแ แแแฃแ แฃแแ แฃแแแแแงแแคแแจแ. แจแแกแแแแแแกแแ, แแแแฎแแแ แแแแแก แกแแฎแแแ แแ แแแ แแแ แแแแแฎแแแแก แแแแกแแแจแ. แฅแแแแแ แแแชแแแฃแแ แกแแ แแแขแแ, แแแแฎแแแ แแแแแก แกแแฎแแแ แแ แแแ แแแ แแแขแแแแขแฃแ แแ แจแแแงแแแแแก:
# $language = "Python"
# $interface = "1.0"
# Connect to a telnet server and automate the initial login sequence.
# Note that synchronous mode is enabled to prevent server output from
# potentially being missed.
def main():
crt.Screen.Synchronous = True
crt.Screen.Send("snmpadminr")
crt.Screen.WaitForString("assword:")
crt.Screen.Send("Passwordr")
crt.Screen.Synchronous = False
main()
แจแแแแจแแแ: แแงแ 2 แกแแ แแแขแ, แแ แแ แแแแแแแกแขแ แแขแแ แแก แแแแแ แแจแแกแแแแก, แแแแ แ eSIGHT แแแแแ แแจแแกแแแแก.
แกแแ แแแขแ แกแแ แแแขแแก แจแแกแ แฃแแแแแก แแ แแก แแแแแชแแแแแแก แฃแจแฃแแแแ แแแแแขแแแแก แจแแกแแซแแแแแแแแ.
แแแแชแแแ แแงแ แกแขแแขแแแฃแ แ แแแ แจแ แฃแขแแก แแแแแขแแแ แฅแกแแแแก แงแแแแ แแแฌแงแแแแแแแแแ. แแแแ แแ แแแขแแ แแแขแแก แแแ แแแญแ แแแแแแฃแ แแแฌแงแแแแแแแแแ แแแแกแฎแแแแแแฃแแ แแงแ (แแ แแก แแแแกแฎแแแแแแแแแ แแแแฃแแแกแฎแแแแ แแแ แแแญแแกแแแ). แจแแแแแ แกแแ แแแขแจแ แแแฉแแแแแแแ แแแ แจแ แฃแขแแแแชแแแก แชแฎแ แแแ, แจแแแแแ แแแแคแแแฃแ แแชแแแก แ แแแแแจแ, แแ แแแฌแแ แ แแ แซแแแแแ แแแแแแแ (แแแขแแ แแแขแแก แแแ แแแญแแก IP แแแกแแแแ แแ) - แแ แแแแแแแขแ แแก แแแฌแแแ. Enter-แแก แแแญแแ แแก แจแแแแแ แกแแ แแแขแแ แแแแแแ แซแ แแ แซแแแแแแก แจแแกแ แฃแแแแ.
# $language = "Python"
# $interface = "1.0"
# Connect to a telnet server and automate the initial login sequence.
# Note that synchronous mode is enabled to prevent server output from
# potentially being missed.
def main():
crt.Screen.Synchronous = True
crt.Screen.Send("Zdes-mogla-bit-vasha-reklamar")
crt.Screen.WaitForString("#")
crt.Screen.Send("show run | inc ip router")
crt.Screen.WaitForString("#")
crt.Screen.Send("conf tr")
crt.Screen.WaitForString("(config)#")
crt.Screen.Send("ip route 10.10.10.8 255.255.255.252 ")
crt.Screen.WaitForString("(config)#")
crt.Screen.Send("endr")
crt.Screen.WaitForString("#")
crt.Screen.Send("copy run star")
crt.Screen.WaitForString("[startup-config]?")
crt.Screen.Send("r")
crt.Screen.WaitForString("#")
crt.Screen.Send("exitr")
crt.Screen.Synchronous = False
main()
แแ แกแแ แแแขแจแ, แกแขแ แแฅแแแจแ: crt.Screen.Send("ip route 10.10.10.8 255.255.255.252") แแแ แแแญแแก IP แแแกแแแแ แแ แแ แแ แแก แแแแแขแแแฃแแ แแ แแ แแ แแก แแแ แแก แแแแ แฃแแแแแก แกแแแแแแ. แกแแ แแแขแ แแแแแแแ แจแแแแแ แกแขแ แแฅแแแก แกแแแแแแแแแแ "(config) #" แแก แกแแแแแแแแแ แแแแแฉแแแ แแแก แจแแแแแ แ แแช แจแแแแงแแแแ ip แแแกแแแแ แแ แแ แจแแแแขแแแ.
แแแกแแแแ:
แกแแ แแแขแแก แแแฌแแ แแกแ แแ แจแแกแ แฃแแแแแกแแก แฃแแแ แแแแชแแแ แฌแแกแ: แกแแ แแแขแแก แแแฌแแ แแกแ แแ แกแแ แแแขแแก แจแแกแ แฃแแแแแก แแ แ แแ แแกแแแแก แฃแแแ แแงแแก แแแแแ แแแขแ, แแแแ แ แแแแ แแฃแแแ แแแฎแแ แฏแฃแแ แแ แแ แแ แแแแแ แกแแแฃแจแแแก แฎแแแแ แจแแกแ แฃแแแแแแ (แแแแแ แแแ/แฉแแกแแ แแแฃแแแฃแฅแแแแ, แฉแแฌแแ แ แแ แแแแแ แแแ). แแแแแแแก แกแแ แแแขแแก แแแกแแฌแแ แ แแ แแแแแ แแฃแแ แกแแแแแแจแ แฌแแแแ). แแแฃ แกแแ แแแขแแก แแแแแงแแแแแแ แฃแแแ แแแแแแแก แแ แ แแ แแ แแแแแ แแแก แแ แ แแ แแชแแกแแแแก แแ แแฏแแ แแ แแแขแแแแขแแแแชแแแแ (แแแฃ แ แแชแ แกแแ แแแขแ แฃแแแแแแฃแ แแ แแ แแฆแแ แแฅแแแแ แแแแแแ แแแ). แแแแ แแ แแฃ แกแแ แแแขแ แฃแแแแแแฃแ แแ แแ แกแแ แแแขแแก แแแขแแแแขแแแแชแแแก แแ แกแแ แแแขแแก แแแฌแแ แ/แแแแแ แแแแก แแแแแแแ แแ แ แกแญแแ แแแแ, แแแแ แ แกแฎแแแแแแ แแ แแแแแแแแแก (ansible, command window), แแแจแแ แกแแ แแแขแ แกแแฃแแแแแกแ แแแแแกแแแแแแ.
แกแแ แแแขแแก แแแแแ แแแ. แกแแ แแแขแ แแแแแแแแ แแแ แแแแ, แแแแแ แแแ แฎแแแแ แแแจแแแแแกแแก แแแ แแแ, แแแแ แ, แแแกแแแ แแแฌแงแแแแแแแแแ แแ แแแแแฎแแกแแแแก แกแแ แแแขแ แแแแ แแแแแแแแแ แกแ แฃแแแ แคแฃแแฅแชแแแแแ แแแก.
แกแแ แแแขแแก แแแจแแแแ (แแแแฎแแแ แแแแแก แกแแฎแแแ+แแแ แแแแก แจแแงแแแแแ) แแแฃแกแแ แฉแแแฃแแแแ แแ แฃแคแ แ แกแฌแ แแคแแ, แแแแ แ แแแแฎแแแ แแแแแก แกแแฎแแแแกแ แแ แแแ แแแแก แฉแแกแแฌแแ แ แแแแแแแแ แแแแแ แแแ. แแแแ แแ แแ แแ แแก แแแชแฃแแ แฃแกแแคแ แแฎแแแแแก แแแแแกแแแ แแกแแ.
แแแแแ แแ แแ (แ แแแแฃแ แ) แแแแแแแแ แกแแ แแแขแแก แแแแแงแแแแแแกแแก: แแฅแแแ แแ แแแฅแแ แแแ แแแแแ แ แฌแแแแแ แฅแกแแแฃแ แแฆแญแฃแ แแแแแแแแ. แแแแ แแ แกแแญแแ แแ แแแแแ แฅแกแแแแก แแฆแญแฃแ แแแแแแแก แแแแคแแแฃแ แแชแแ (แจแแแขแแแแ แแแ แแแแแขแแ แแแแแก แกแแกแขแแแแจแ, แแแแแแแคแแแฃแ แแ แแ แแแแแขแแแแแ แแแแฎแแแ แแแแแก แกแแฎแแแ/แแแ แแแ/snmpv3 แแแแฎแแแ แแแแแก แกแแฎแแแ/แแแ แแแ). แแ แกแแแแแก แฌแแแแแ Core แแแแแแ แแแแแแ แแแแแกแแแแกแแก, แแแกแแแ แฎแกแแแ SSH แกแฎแแ แแฆแญแฃแ แแแแแแแก. แ แแขแแ แแ แจแแแแซแแแแ แแแแแแงแแแแ Ansible. - แแแแก แแแแ, แ แแ แฉแแแ แแแแฅแแก แจแแแฆแฃแแแ แฅแกแแแฃแ แแฆแญแฃแ แแแแแแแแ แแแจแแแแฃแแ แแ แแแ แแฃแแ แกแแกแแแแแก แ แแแแแแแแแแ (แฎแแแ vty 0 4, แแแแฎแแแ แแแแแก แแแขแแ แคแแแกแ vty 0 4) (แแแแแ แแ แแ แแแแฎแแแ, แแฃ แ แแแแ แฃแแแ แแแแแฌแงแแ แกแฎแแแแแกแฎแแ แแฆแญแฃแ แแแแแแ Ansible-แจแ แแแแแ SSH แแแ แแแแ แแแแแฎแ แแ).
แกแแ แแแขแ แแแชแแ แแแก แแ แแก แฎแแแแ แซแแแแ แแแแ แแชแแแแแก แแ แแก - แแแแแแแแแ, แคแแแแแแแก แแแแแ แแแ FTP-แแก แกแแจแฃแแแแแแ. แแแแแ แแแแก แแแกแ แฃแแแแแก แจแแแแแ แกแแ แแแขแ แแแฃแงแแแแแแแแ แแฌแงแแแก แแฃแจแแแแแก. แแแแแแแแก แแแกแญแแ แแแแ แแแฎแแก แแแแแ แแแแก แแแกแแกแ แฃแแ, แจแแแแแ แแแแชแแแแแแ แแก แแแแแ แแแแก แแแกแแกแ แฃแแ, แจแแแแแ แจแแแงแแแแแก แจแแกแแแแแแกแ แแ แซแแแแแแแ. แกแชแแแแ แ แแแแก แแแแแฅแขแฃแ แแ แฃแคแ แ แกแฌแ แแคแแ แแแแแแแก.
แกแแ แแแขแแแ แแแแแแงแแแแแ แแฅ, แกแแแแช แจแแฃแซแแแแแแแ แแแแแชแแแแ แแแกแแแ แแแ แแแฌแแแแแแก แฎแแแกแแฌแงแแแแแก แแแแแงแแแแแ: แแแแกแแแ. แแ แ แแชแ แแฆแญแฃแ แแแแแแแก แแแแแแ แแ แแแแแชแแแ แฃแแแแแแฃแ แแ: แฐแแกแขแแก แกแแฎแแแ, แแแ แแแแก IP แแแกแแแแ แแ. แแ แแ แแแ แแแแก แแแฌแแ แแกแแก แแ แแแแแ แแแแกแแก แแก แฃแคแ แ แ แแฃแแแ, แแแแ แ แกแแ แแแขแแก แแฃแจแแแแแก แแ แแก แแฆแญแฃแ แแแแแแแแแ แแแฆแแแฃแแ แแแแแชแแแแแแก แแแแแขแแแ. - แแแแแแแแ แแแ แจแ แฃแขแแก แแแแแจแแแแก แกแแ แแแขแแ, แ แแแแกแแช แแแแแแฃแ แแแฌแงแแแแแแแแก แแฅแแก แแแขแแ แแแข แแ แแแแแแแ แแก แกแแแฃแแแ แ IP แแแกแแแแ แแ. (แฉแแแ แแแแแแแแ แฌแแ แแแแ แแกแแ แกแแ แแแขแแแก - แ แแชแ DMVPN แกแแฃแแ แแแแ 3-แแ แแแขแ แแงแ. แกแแญแแ แ แแงแ DMVPN แแแ แแแแขแ แแแแก แจแแชแแแ).
แจแแแแฎแแแแแก แจแแกแฌแแแแ: แกแแฌแงแแกแ แแแ แแแแขแ แแแแก แแแแคแแแฃแ แแชแแ แแฎแแ แแแแแแ แแแแแแ แแแแกแแแแก แแแ แขแแแแก แแแแแงแแแแแแ:
แ. แแแแกแแแแก แแแแแแ แจแแแแ แแ แแแฌแงแแแแแแแแจแ.
B. แแแฃแจแแแ แกแแ แแแขแ
แ. แแแแแแแ แกแชแแแแ แแก แจแแกแ แฃแแแแแก
D. แจแแแแ แแแ แแแแกแแแแก แแแแแแ แจแแแแแ แแแฌแงแแแแแแแแจแ.
E. แแฃ แแแแแแ แแแแแ แแ แแ แแก แแแแ, แแแแแแแ B แกแแคแแฎแฃแ แแ.
แกแชแแแแ แแก แแฃแจแแแแแก แจแแแแแแ:
- แกแแฌแงแแกแ แแแ แแแ แแแงแแแแแฃแแแ แแแฌแงแแแแแแแแแ.
- แแแแฎแแแ แแแแแก แกแแฎแแแ แจแแงแแแแแแแ
- แจแแแงแแแแแแ แแแฌแงแแแแแแแแก แฃแแแแแแฃแ แ IP แแแกแแแแ แแ.
แ.แก แแแแ แแชแแ แฃแแแ แแแแแแแ แแแก. แ แแแแแ แแแแฃแแแกแฎแแแแ ssh แแ แแงแ แแแแคแแแฃแ แแ แแแฃแแ/แแแแแ แแฃแแ. (แแแแฎ, แแก แฉแแแ แจแแชแแแแแ.)
แแแแแงแแแแแฃแแ แฌแงแแ แแแแ.
1.
2.
แแแแแ แแ 1: แกแแ แแแขแแแแก แแแแฃแจแ.
แแ แซแแแ แกแแ แแแขแแก แแแแแแแแ, แแ แ แแแแฎแแแแแ: แฐแแกแขแแก แกแแฎแแแ แแ IP แแแกแแแแ แแ. แแแ แจแแแฅแแแ แแแแกแแแแก แกแแจแฃแแแแแแ แแฆแญแฃแ แแแแแแแก แฌแแแแกแฌแแ แแแกแแงแแแแแแแ (9600 baud). แแ แแกแแแ แแแแแแแแแก แแฆแญแฃแ แแแแแแแก แแแแจแแ แ แฅแกแแแแแ.
# $language = "Python"
# $interface = "1.0"
# Connect to a telnet server and automate the initial login sequence.
# Note that synchronous mode is enabled to prevent server output from
# potentially being missed.
def main():
crt.Screen.Synchronous = True
crt.Screen.Send("r")
crt.Screen.WaitForString("name")
crt.Screen.Send("adminr")
crt.Screen.WaitForString("Password:")
crt.Screen.Send("Passwordr")
crt.Screen.Send("sysr")
crt.Screen.WaitForString("]")
crt.Screen.Send("interface Vlanif 1r")
crt.Screen.WaitForString("Vlanif1]")
crt.Screen.Send("undo ip addressr")
crt.Screen.Send("shutdownr")
crt.Screen.Send("vlan 100r")
crt.Screen.Send(" description description1r")
crt.Screen.Send(" name description1r")
crt.Screen.Send("vlan 110r")
crt.Screen.Send(" description description2r")
crt.Screen.Send(" name description2r")
crt.Screen.Send("vlan 120r")
crt.Screen.Send(" description description3r")
crt.Screen.Send(" name description3r")
crt.Screen.Send("vlan 130r")
crt.Screen.Send(" description description4r")
crt.Screen.Send(" name description4r")
crt.Screen.Send("vlan 140r")
crt.Screen.Send(" description description5r")
crt.Screen.Send(" name description5r")
crt.Screen.Send("vlan 150r")
crt.Screen.Send(" description description6r")
crt.Screen.Send(" name description6r")
crt.Screen.Send("vlan 160r")
crt.Screen.Send(" description description7r")
crt.Screen.Send(" name description7r")
crt.Screen.Send("vlan 170r")
crt.Screen.Send(" description description8r")
crt.Screen.Send(" name description8r")
crt.Screen.Send("vlan 180r")
crt.Screen.Send(" description description9r")
crt.Screen.Send(" name description9r")
crt.Screen.Send("vlan 200r")
crt.Screen.Send(" description description10r")
crt.Screen.Send(" name description10r")
crt.Screen.Send("vlan 300r")
crt.Screen.Send(" description description11r")
crt.Screen.Send(" name description11r")
crt.Screen.Send("quitr")
crt.Screen.WaitForString("]")
crt.Screen.Send("stp region-configurationr")
crt.Screen.Send("region-name descr")
crt.Screen.Send("active region-configurationr")
crt.Screen.WaitForString("mst-region]")
crt.Screen.Send("quitr")
crt.Screen.Send("stp instance 0 priority 57344r")
crt.Screen.WaitForString("]")
crt.Screen.Send("interface range GigabitEthernet 0/0/1 to GigabitEthernet 0/0/42r")
crt.Screen.WaitForString("port-group]")
crt.Screen.Send("description Usersr")
crt.Screen.WaitForString("port-group]")
crt.Screen.Send("port link-type hybridr")
crt.Screen.WaitForString("port-group]")
crt.Screen.Send("voice-vlan 100 enabler")
crt.Screen.WaitForString("port-group]")
crt.Screen.Send("voice-vlan legacy enabler")
crt.Screen.WaitForString("port-group]")
crt.Screen.Send("port hybrid pvid vlan 120r")
crt.Screen.WaitForString("port-group]")
crt.Screen.Send("port hybrid tagged vlan 100r")
crt.Screen.WaitForString("port-group]")
crt.Screen.Send("port hybrid untagged vlan 120r")
crt.Screen.WaitForString("port-group]")
crt.Screen.Send("stp edged-port enabler")
crt.Screen.WaitForString("port-group]")
crt.Screen.Send("trust 8021pr")
crt.Screen.WaitForString("port-group]")
crt.Screen.Send("storm-control broadcast min-rate 1000 max-rate 1500r")
crt.Screen.WaitForString("port-group]")
crt.Screen.Send("storm-control multicast min-rate 1000 max-rate 1500r")
crt.Screen.WaitForString("port-group]")
crt.Screen.Send("storm-control action blockr")
crt.Screen.WaitForString("port-group]")
crt.Screen.Send("storm-control enable trapr")
crt.Screen.WaitForString("port-group]")
crt.Screen.Send("quitr")
crt.Screen.Send("interface range GigabitEthernet 0/0/43 to GigabitEthernet 0/0/48r")
crt.Screen.WaitForString("port-group]")
crt.Screen.Send("description Printersr")
crt.Screen.WaitForString("port-group]")
crt.Screen.Send("port link-type accessr")
crt.Screen.WaitForString("port-group]")
crt.Screen.Send("port default vlan 130r")
crt.Screen.WaitForString("port-group]")
crt.Screen.Send("stp edged-port enabler")
crt.Screen.WaitForString("port-group]")
crt.Screen.Send("trust 8021pr")
crt.Screen.WaitForString("port-group]")
crt.Screen.Send("storm-control broadcast min-rate 1000 max-rate 1500r")
crt.Screen.WaitForString("port-group]")
crt.Screen.Send("storm-control multicast min-rate 1000 max-rate 1500r")
crt.Screen.WaitForString("port-group]")
crt.Screen.Send("storm-control action blockr")
crt.Screen.WaitForString("port-group]")
crt.Screen.Send("storm-control enable trapr")
crt.Screen.WaitForString("port-group]")
crt.Screen.Send("quitr")
crt.Screen.Send("interface range XGigabitEthernet 0/0/1 to XGigabitEthernet 0/0/2r")
crt.Screen.WaitForString("port-group]")
crt.Screen.Send("description uplinkr")
crt.Screen.WaitForString("port-group]")
crt.Screen.Send("port link-type trunkr")
crt.Screen.WaitForString("port-group]")
crt.Screen.Send("port trunk allow-pass vlan 100 110 120 130 140 150 160 170 180 200r")
crt.Screen.WaitForString("port-group]")
crt.Screen.Send("port trunk allow-pass vlan 300r")
crt.Screen.WaitForString("port-group]")
crt.Screen.Send("storm-control broadcast min-rate 1000 max-rate 1500r")
crt.Screen.WaitForString("port-group]")
crt.Screen.Send("storm-control multicast min-rate 1000 max-rate 1500r")
crt.Screen.WaitForString("port-group]")
crt.Screen.Send("storm-control action blockr")
crt.Screen.WaitForString("port-group]")
crt.Screen.Send("storm-control enable trapr")
crt.Screen.WaitForString("port-group]")
crt.Screen.Send("quitr")
crt.Screen.Send("ntp-service unicast-server 10.10.10.4r")
crt.Screen.Send("ntp-service unicast-server 10.10.10.2r")
crt.Screen.Send("ntp-service unicast-server 10.10.10.134r")
crt.Screen.Send("ip route-static 0.0.0.0 0.0.0.0 10.10.10.254r")
crt.Screen.Send("interface Vlanif 200r")
crt.Screen.WaitForString("-Vlanif200]")
crt.Screen.Send("r")
crt.Screen.WaitForString("-Vlanif200]")
crt.Screen.Send("r")
crt.Screen.WaitForString("-Vlanif200]")
crt.Screen.Send("r")
crt.Screen.WaitForString("-Vlanif200]")
crt.Screen.Send("r")
crt.Screen.WaitForString("-Vlanif200]")
crt.Screen.Send("r")
crt.Screen.WaitForString("-Vlanif200]")
crt.Screen.Send("r")
crt.Screen.WaitForString("-Vlanif200]")
crt.Screen.Send("r")
crt.Screen.WaitForString("-Vlanif200]")
hostnamestr = crt.Dialog.Prompt("Enter hostname:", "hostname", "", False)
ipaddressstr = crt.Dialog.Prompt("Enter ip address:", "ip", "", False)
crt.Screen.Send("ip address 10.10.10.")
crt.Screen.Send(ipaddressstr)
crt.Screen.Send(" 24r")
crt.Screen.Send("quitr")
crt.Screen.Send("sysname ")
crt.Screen.Send(hostnamestr)
crt.Screen.Send("r")
crt.Screen.WaitForString("]")
crt.Screen.Synchronous = False
main()
แแกแแแ แกแแ แแแขแแแ, แ แแแแ แช แฌแแกแ, แแ แแ แแก แกแแญแแ แ, แแแแ แแ แแฆแญแฃแ แแแแแแแก แ แแแแแแแแ แแ แแก 15 แชแแแ. แแแจแแแแฃแแแ แฃแคแ แ แกแฌแ แแคแ แแแงแแแแแ. แฃแคแ แ แกแฌแ แแคแ แแงแ แแฆแญแฃแ แแแแแแแก แแแงแแแแแ SecureCRT แแ แซแแแแแแก แคแแแฏแ แแก แแแแแงแแแแแแ.
แแแแแ แแจแแก แแแงแแแแแ ssh-แกแแแแก.
แฒกแฎแแ แแแแแแแแ. แแแแคแแแฃแ แแชแแ แแกแแแ แฎแแแแ แแแแกแแแแก แกแแจแฃแแแแแแ.
# $language = "Python"
# $interface = "1.0"
# Connect to a telnet server and automate the initial login sequence.
# Note that synchronous mode is enabled to prevent server output from
# potentially being missed.
def main():
crt.Screen.Synchronous = True
crt.Screen.Send("r")
crt.Screen.WaitForString("name")
crt.Screen.Send("adminr")
crt.Screen.WaitForString("Password:")
crt.Screen.Send("Passwordr")
crt.Screen.WaitForString(">")
crt.Screen.Send("sysr")
crt.Screen.Send("stelnet server enabler")
crt.Screen.Send("aaar")
crt.Screen.Send("local-user admin service-type terminal ftp http sshr")
crt.Screen.Send("quitr")
crt.Screen.Send("user-interface vty 0 4r")
crt.Screen.Send("authentication-mode aaar")
crt.Screen.Send("quitr")
crt.Screen.Send("quitr")
crt.Screen.Synchronous = False
main()
SecureCRT-แแก แจแแกแแฎแแ:แคแแกแแแแ แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแ: $99-แแแ (แงแแแแแแ แแชแแ แ แคแแกแ แแ แแก แแฎแแแแ SecureCRT แแ แแ แฌแแแก แแแแแแแแแแแจแ)
แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แแแชแแแแแ แจแแซแแแแแแ แแ แแฎแแ, แแฎแแ แแแญแแ แแ (แแแแแฎแแแแแกแแแแก), แจแแแแแ แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแ แแแแแแงแแแแแ แแ แแแชแแแแแแ แจแแฃแแฆแฃแแแแ แแ แแแ.
แแฃแจแแแแก Mac OS X แแ Windows แแแแ แแชแแฃแ แกแแกแขแแแแแแ.
แแ แกแแแแแก แกแแ แแแขแแก แแฎแแ แแแญแแ แ (แแก แกแขแแขแแ)
แแ แกแแแแแก
แกแแ แแฃแแ/Telnet/SSH1/SSH2/Shell แแแแ แแชแแฃแแ แกแแกแขแแแ
แฌแงแแ แ: www.habr.com