def connect(args):
if args['PROTOCOL'] == "telnet":
from telnetlib import Telnet
conn = Telnet(args['IP'], args['PORT'])
conn.read_until(b'Password: '******'SWITCH_PASSWORD'] + '\n'))
conn.write(b'enable\n')
if args['ENABLE_PASSWD']:
conn.read_until(b'Password: '******'ENABLE_PASSWD'] + '\n'))
elif args['PROTOCOL'] == "ssh":
import paramiko
conn = paramiko.Transport((args['IP'], args['PORT']))
conn.connect(username=args['USERNAME'], password=args['SSH_PASSWORD'])
conn = conn.open_channel(kind='session')
# Check if the connection is established
response = read_all(connection=conn, command='show version\n')
if len(response.split("\n")) < 4:
raise Exception(
colored(
"The connection could not be established using \
your credentials. Check them again: " + str(args), "red"))
yield conn
conn.close()
class CMonitor(CElement):
def __init__(self, monitor_info):
super(CMonitor, self).__init__()
self.__monitor = monitor_info
self.__chardev = None
self.__mode = "readline"
self.__workspace = ""
self.__monitor_handle = None
def get_workspace(self):
return self.__workspace
def set_workspace(self, ws):
self.__workspace = ws
def precheck(self):
if self.__mode not in ["readline", "control"]:
raise ArgsNotCorrect("[Monitor] Invalid monitor mode: {}".format(
self.__mode))
self.__chardev.precheck()
# Monitor specific chardev attribution
if self.__monitor["chardev"]["backend"] != "socket":
raise ArgsNotCorrect(
"[Monitor] Invalid monitor chardev backend: {}".format(
self.__monitor["chardev"]["backend"]))
if self.__monitor["chardev"]["server"] is not True:
raise ArgsNotCorrect(
"[Monitor] Invalid monitor chardev server: {}".format(
self.__monitor["chardev"]["server"]))
if self.__monitor["chardev"]["wait"] is not False:
raise ArgsNotCorrect(
"[Monitor] Invalid monitor chardev wait: {}".format(
self.__monitor["chardev"]["wait"]))
def init(self):
self.__mode = self.__monitor.get("mode", "readline")
chardev_info = {}
if self.__mode == "readline":
chardev_info = self.__monitor.get("chardev", {})
if "backend" not in chardev_info:
chardev_info["backend"] = "socket"
if "server" not in chardev_info:
chardev_info["server"] = True
if "wait" not in chardev_info:
chardev_info["wait"] = False
if "host" not in chardev_info:
chardev_info["host"] = "127.0.0.1"
if "port" not in chardev_info:
chardev_info["port"] = 2345
elif self.__mode == "control":
chardev_info = self.__monitor.get("chardev", {})
if "backend" not in chardev_info:
chardev_info["backend"] = "socket"
if "server" not in chardev_info:
chardev_info["server"] = True
if "wait" not in chardev_info:
chardev_info["wait"] = False
if "path" not in chardev_info:
if self.get_workspace():
chardev_path = os.path.join(self.get_workspace(),
".monitor")
else:
chardev_path = os.path.join(config.infrasim_etc,
".monitor")
chardev_info["path"] = chardev_path
else:
pass
self.__monitor["chardev"] = chardev_info
self.__chardev = CCharDev(chardev_info)
self.__chardev.logger = self.logger
self.__chardev.set_id("monitorchardev")
self.__chardev.init()
def handle_parms(self):
self.__chardev.handle_parms()
self.add_option(self.__chardev.get_option())
self.add_option("-mon chardev={},mode={}".format(
self.__chardev.get_id(), self.__mode))
def get_mode(self):
return self.__mode
def open(self):
if self.__mode == "readline":
self.__monitor_handle = Telnet(self.__chardev.host,
self.__chardev.port)
elif self.__mode == "control":
self.__monitor_handle = socket.socket(socket.AF_UNIX,
socket.SOCK_STREAM)
self.__monitor_handle.connect(self.__chardev.get_path())
# enable qmp capabilities
qmp_payload = {"execute": "qmp_capabilities"}
self.send(qmp_payload)
else:
raise ArgsNotCorrect(
"[Monitor] Monitor mode {} is unknown.".format(self.__mode))
self.logger.info("[Monitor] monitor opened({}).".format(
self.__monitor_handle))
def send(self, command):
if self.__monitor_handle:
self.logger.info("[Monitor] send command {}".format(command))
if self.__mode == "readline":
self.__monitor_handle.write(command)
else:
self.__monitor_handle.send(json.dumps(command))
def close(self):
if self.__monitor_handle:
self.__monitor_handle.close()
self.logger.info("[Monitor] monitor closed.")
def ios_catos(region, operatingsystem, connectionname, tunnel, credentials,
backuploc, reportlist, errorlist):
'''
:param region: - inherited region
:param operatingsystem: - inherited operating system
:param connectionname: - inherited connection name - ip preferred, else hostname
:param tunnel: - telnet or ssh, decides which path it takes
:param credentials: - credentials in use, a list of 4 items
:param backuploc: - location of the eventual saved config dump
:param reportlist: - report list, to pass to addtoreportdata function
:param errorlist: - error list, to pass to addtoreportdata function
:return: - null
'''
user = credentials[0]
pw = credentials[1]
en_pw = credentials[2]
hostname = credentials[3]
if tunnel == 'telnet':
rawexpectedoutput = [
'Authentication failed', 'Access denied', 'Invalid input',
'Username:'******'Password:'******' [(]enable[)]',
hostname + '#', '>'
]
expectedoutput = [str.encode('(?i)' + x) for x in rawexpectedoutput]
try:
relevant_pw = pw.encode('ascii')
except AttributeError:
relevant_pw = pw
try:
relevant_en_pw = en_pw.encode('ascii')
except AttributeError:
relevant_en_pw = en_pw
try:
relevant_user = user.encode('ascii')
except AttributeError:
relevant_user = user
try:
sock = Telnet(connectionname)
pwgiven = False
while True:
expectresult = sock.expect(expectedoutput, 30)
if expectresult[0] == -1:
# misc error
addtoreportdata(region, connectionname, hostname,
'UNEXPECTED OUTPUT AT LOGIN', reportlist,
errorlist)
sock.close()
return
elif expectresult[0] <= 2:
# authentication error
addtoreportdata(region, connectionname, hostname,
'AUTHENTICATION FAILED', reportlist,
errorlist)
sock.close()
return
elif expectresult[0] == 3:
sock.write(relevant_user + b'\n')
elif expectresult[0] == 4:
sock.write(relevant_pw + b'\n')
pwgiven = True
elif pwgiven:
if expectresult[0] != 0:
break # escapes loop
else:
# authentication error
addtoreportdata(region, connectionname, hostname,
'AUTHENTICATION FAILED', reportlist,
errorlist)
sock.close()
return
time.sleep(1)
sock.write(b'enable\n')
sock.read_until(b'Password:'******'\n')
expectresult = sock.expect(expectedoutput, 30)
if expectresult[0] == -1:
# misc error
addtoreportdata(region, connectionname, hostname,
'UNEXPECTED OUTPUT WITH ENABLE MODE',
reportlist, errorlist)
sock.close()
return
elif expectresult[0] <= 1:
addtoreportdata(region, connectionname, hostname,
'AUTHENTICATION FAILED ENTERING ENABLE MODE',
reportlist, errorlist)
sock.close()
return
elif expectresult[0] == 2:
addtoreportdata(region, connectionname, hostname,
'INVALID INPUT ENTERING ENABLE MODE',
reportlist, errorlist)
sock.close()
return
sock.write(b'set length 0\n')
sock.write(b'terminal len 0\n')
authresult = sock.expect(expectedoutput, 30)
if authresult[0] == -1:
# misc error
addtoreportdata(region, connectionname, hostname,
'UNEXPECTED OUTPUT AFTER ENABLE MODE',
reportlist, errorlist)
sock.close()
return
elif authresult[0] == 1:
addtoreportdata(region, connectionname, hostname,
'AUTHENTICATION FAILED ENTERING ENABLE MODE',
reportlist, errorlist)
sock.close()
return
sock.write(b'show run\n')
time.sleep(1)
checkrun = sock.read_very_eager()
if b'Building configuration...' in checkrun:
# avoids repetition if the prior command worked, but also need to add the captured output
decodedoutput = checkrun.decode()
else:
decodedoutput = ''
sock.write(b'show running-config\n')
sock.write(b'echo neo collector done, stage 1/2\n')
output = sock.read_until(b'neo collector done, stage 1/2', 30)
sock.write(b'show version\n')
sock.write(b'echo neo collector done, stage 2/2\n')
lcmoutput = sock.read_until(b'neo collector done, stage 2/2', 30)
decodedoutput += output.decode()
with open(backuploc, 'w') as outputfile:
outputfile.write('Assumed Operating System: ' +
operatingsystem + '\n\n')
outputfile.write(decodedoutput)
outputfile.write('\n\n' + '=' * 20 + '\n\n')
outputfile.write(lcmoutput.decode())
addtoreportdata(region, connectionname, hostname, 'SUCCESS',
reportlist, errorlist, True)
sock.close()
except:
writeerrorlog(hostname, traceback.format_exc())
addtoreportdata(region, connectionname, hostname,
'MISCELLANEOUS ERROR', reportlist, errorlist)
elif tunnel == 'ssh':
try:
relevant_pw = pw.decode()
except AttributeError:
relevant_pw = pw
try:
relevant_en_pw = en_pw.decode()
except AttributeError:
relevant_en_pw = en_pw
try:
relevant_user = user.decode()
except AttributeError:
relevant_user = user
# Create a paramiko ssh client object and load keys.
# Any missing keys are added to the system.
sock = paramiko.SSHClient()
sock.load_system_host_keys()
sock.set_missing_host_key_policy(paramiko.AutoAddPolicy())
# Connect to the device using port 22.
try:
sock.connect(connectionname, 22, relevant_user, relevant_pw)
except:
writeerrorlog(hostname, traceback.format_exc())
addtoreportdata(region, connectionname, hostname,
'AUTHENTICATION FAILED', reportlist, errorlist)
sock.close()
return
# Cisco devices need to use invoke shell otherwise they
# drop the connection after 1 command.
shell = sock.invoke_shell()
shell.send('enable\n')
time.sleep(3)
shell.send(relevant_en_pw + '\n')
time.sleep(3)
output = collecttotaloutput(shell)
if 'Access denied' in output:
addtoreportdata(region, connectionname, hostname,
'AUTHENTICATION FAILED ENTERING ENABLE MODE',
reportlist, errorlist)
sock.close()
return
elif not '(enable)' in output and not '#' in output:
# misc error
addtoreportdata(region, connectionname, hostname,
'UNEXPECTED OUTPUT AFTER ENABLE MODE', reportlist,
errorlist)
sock.close()
return
shell.send('set length 0\n')
time.sleep(1)
shell.send('terminal len 0\n')
time.sleep(1)
shell.send('show running-config\n')
time.sleep(5)
shell.send('show run\n')
time.sleep(5)
output = collecttotaloutput(shell)
shell.send('show version\n')
time.sleep(5)
lcmoutput = collecttotaloutput(shell)
with open(backuploc, 'w') as outputfile:
outputfile.write(operatingsystem + '\n\n')
outputfile.write(output)
outputfile.write('=' * 20 + '\n\n')
outputfile.write(lcmoutput)
addtoreportdata(region, connectionname, hostname, 'SUCCESS',
reportlist, errorlist, True)
shell.send('exit\n')
sock.close()
class CMonitor(CElement):
def __init__(self, monitor_info):
super(CMonitor, self).__init__()
self.__monitor = monitor_info
self.__chardev = None
self.__mode = "readline"
self.__workspace = ""
self.__monitor_handle = None
def get_workspace(self):
return self.__workspace
def set_workspace(self, ws):
self.__workspace = ws
def precheck(self):
if self.__mode not in ["readline", "control"]:
raise ArgsNotCorrect("[Monitor] Invalid monitor mode: {}".format(self.__mode))
self.__chardev.precheck()
# Monitor specific chardev attribution
if self.__monitor["chardev"]["backend"] != "socket":
raise ArgsNotCorrect("[Monitor] Invalid monitor chardev backend: {}".
format(self.__monitor["chardev"]["backend"]))
if self.__monitor["chardev"]["server"] is not True:
raise ArgsNotCorrect("[Monitor] Invalid monitor chardev server: {}".
format(self.__monitor["chardev"]["server"]))
if self.__monitor["chardev"]["wait"] is not False:
raise ArgsNotCorrect("[Monitor] Invalid monitor chardev wait: {}".
format(self.__monitor["chardev"]["wait"]))
def init(self):
self.__mode = self.__monitor.get("mode", "readline")
chardev_info = {}
if self.__mode == "readline":
chardev_info = self.__monitor.get("chardev", {})
if "backend" not in chardev_info:
chardev_info["backend"] = "socket"
if "server" not in chardev_info:
chardev_info["server"] = True
if "wait" not in chardev_info:
chardev_info["wait"] = False
if "host" not in chardev_info:
chardev_info["host"] = "127.0.0.1"
if "port" not in chardev_info:
chardev_info["port"] = 2345
elif self.__mode == "control":
chardev_info = self.__monitor.get("chardev", {})
if "backend" not in chardev_info:
chardev_info["backend"] = "socket"
if "server" not in chardev_info:
chardev_info["server"] = True
if "wait" not in chardev_info:
chardev_info["wait"] = False
if "path" not in chardev_info:
if self.get_workspace():
chardev_path = os.path.join(self.get_workspace(), ".monitor")
else:
chardev_path = os.path.join(config.infrasim_etc, ".monitor")
chardev_info["path"] = chardev_path
else:
pass
self.__monitor["chardev"] = chardev_info
self.__chardev = CCharDev(chardev_info)
self.__chardev.logger = self.logger
self.__chardev.set_id("monitorchardev")
self.__chardev.init()
def handle_parms(self):
self.__chardev.handle_parms()
self.add_option(self.__chardev.get_option())
self.add_option("-mon chardev={},mode={}".format(self.__chardev.get_id(), self.__mode))
def get_mode(self):
return self.__mode
def open(self):
if self.__mode == "readline":
self.__monitor_handle = Telnet(self.__chardev.host, self.__chardev.port)
elif self.__mode == "control":
self.__monitor_handle = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
self.__monitor_handle.connect(self.__chardev.get_path())
# enable qmp capabilities
qmp_payload = {
"execute": "qmp_capabilities"
}
self.send(qmp_payload)
else:
raise ArgsNotCorrect("[Monitor] Monitor mode {} is unknown.".format(self.__mode))
self.logger.info("[Monitor] monitor opened({}).".format(self.__monitor_handle))
def send(self, command):
if self.__monitor_handle:
self.logger.info("[Monitor] send command {}".format(command))
if self.__mode == "readline":
self.__monitor_handle.write(command)
else:
self.__monitor_handle.send(json.dumps(command))
def close(self):
if self.__monitor_handle:
self.__monitor_handle.close()
self.logger.info("[Monitor] monitor closed.")
