def run_command(self, host, command, username=None, port=None, progress_stderr=None): if not isinstance(command, bytes): raise TypeError(command) if port is None: port = 22 client = paramiko.SSHClient() policy = paramiko.client.MissingHostKeyPolicy() client.set_missing_host_key_policy(policy) client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) client.connect(host, username=username, port=port, **self.ssh_kwargs) # Open SSH session channel = client.get_transport().open_session() # Run commands channel.exec_command(command) from dulwich.contrib.paramiko_vendor import ( _ParamikoWrapper as ParamikoWrapper) return ParamikoWrapper( client, channel, progress_stderr=progress_stderr)
def run_command(self, host, command, username=None, port=None, progress_stderr=None): if not isinstance(command, bytes): raise TypeError(command) if port is None: port = 22 client = paramiko.SSHClient() client.set_missing_host_key_policy(AutoAcceptPolicy()) client.connect(host, username=username, port=port, **self.ssh_kwargs) channel = client.get_transport().open_session() channel.exec_command(command) def progress_stderr(s): import sys sys.stderr.write(s.decode("utf-8")) sys.stderr.flush() try: from dulwich.client import ParamikoWrapper except ImportError: from dulwich.contrib.paramiko_vendor import _ParamikoWrapper as ParamikoWrapper return ParamikoWrapper(client, channel, progress_stderr=progress_stderr)
def run_command(self, host, command, username=None, port=None, progress_stderr=None): if not isinstance(command, bytes): raise TypeError(command) # Paramiko needs an explicit port. None is not valid if port is None: port = 22 client = paramiko.SSHClient() policy = paramiko.client.MissingHostKeyPolicy() client.set_missing_host_key_policy(policy) client.connect(host, username=username, port=port, **self.ssh_kwargs) # Open SSH session channel = client.get_transport().open_session() # Run commands channel.exec_command(command) return _ParamikoWrapper(client, channel, progress_stderr=progress_stderr)
def run_command(self, host, command, username=None, port=None, progress_stderr=None, password=None, pkey=None, key_filename=None, **kwargs): client = paramiko.SSHClient() connection_kwargs = {'hostname': host} connection_kwargs.update(self.kwargs) if username: connection_kwargs['username'] = username if port: connection_kwargs['port'] = port if password: connection_kwargs['password'] = password if pkey: connection_kwargs['pkey'] = pkey if key_filename: connection_kwargs['key_filename'] = key_filename connection_kwargs.update(kwargs) policy = paramiko.client.MissingHostKeyPolicy() client.set_missing_host_key_policy(policy) client.connect(**connection_kwargs) # Open SSH session channel = client.get_transport().open_session() # Run commands channel.exec_command(command) return _ParamikoWrapper( client, channel, progress_stderr=progress_stderr)
def ssh(hostname=None, username=None): client = SSHClient() kw = {'hostname': hostname or nodes[0]} if username: kw['username'] = username client.connect(**kw) return client
def reload_vm(vmname, mastervol=None, vmhost='bruce.openend.se', wait=True): if mastervol is None: cmd = '/usr/local/bin/reloadvm -y {vmname} -pubkey - ' else: cmd = '/usr/local/bin/reloadvm -y {vmname} -pubkey - {mastervol}' with SSHClient() as client: client.connect(vmhost) keys = list(map(open, glob.glob(os.path.expanduser('~/.ssh/id_*.pub')))) with contextlib.nested(*keys): client.run(cmd.format(**locals()), stdin=itertools.chain(*keys)) stop = time.time() + 60 while True: try: with SSHClient() as client: client.connect(vmname) stdout = StringIO() client.run('/bin/hostname', stdout=stdout) assert stdout.getvalue().strip() == vmname except paramiko.ssh_exception.NoValidConnectionsError: if time.time() > stop: raise continue else: break
def run_command(self, host, command, username=None, port=None, progress_stderr=None): if port is None: port = 22 client = paramiko.SSHClient() client.set_missing_host_key_policy(AutoAcceptPolicy()) client.connect(host, username=username, port=port, **self.ssh_kwargs) channel = client.get_transport().open_session() channel.exec_command(command) def progress_stderr(s): import sys sys.stderr.write(s.decode("utf-8")) sys.stderr.flush() try: from dulwich.client import ParamikoWrapper except ImportError: from dulwich.contrib.paramiko_vendor import (_ParamikoWrapper as ParamikoWrapper) return ParamikoWrapper(client, channel, progress_stderr=progress_stderr)
def test_007_Revert_back_the_changes(self): print("Revert back the changes") client = paramiko.SSHClient() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) privatekeyfile = os.path.expanduser('~/.ssh/id_rsa') mykey = paramiko.RSAKey.from_private_key_file(privatekeyfile) client.connect(config.grid_vip, username='******', pkey = mykey) data="mount -o remount,rw /" stdin, stdout, stderr = client.exec_command(data) stdout=stdout.read() print(type(stdout)) client.close() child=pexpect.spawn("ssh root@"+config.grid_vip, maxread=4000) try: child.expect("-bash-4.0#",timeout=100) child.sendline("scp root@"+config.client_vip+":/import/qaddi/API_Automation/WAPI_PyTest/suites/customer_bug_automation/fastpath_control /infoblox/one/bin/fastpath_control") child.expect('password:',timeout=100) child.sendline("infoblox") child.expect("-bash-4.0#") child.sendline("exit") print("\nSuccess: Revert back the changes") child.close() assert True except Exception as e: child.close() print (e) print("Failure: Revert back the changes") assert False
def run_command(self, host, command, username=None, port=None, progress_stderr=None): if (type(command) is not list or not all([isinstance(b, bytes) for b in command])): raise TypeError(command) # Paramiko needs an explicit port. None is not valid if port is None: port = 22 client = paramiko.SSHClient() policy = paramiko.client.MissingHostKeyPolicy() client.set_missing_host_key_policy(policy) client.connect(host, username=username, port=port, **self.ssh_kwargs) # Open SSH session channel = client.get_transport().open_session() # Quote command assert command assert is_shell_safe(command[0]) quoted_command = ( command[0] + b' ' + b' '.join( shell_quote(c) for c in command[1:])) # Run commands channel.exec_command(quoted_command) return _ParamikoWrapper( client, channel, progress_stderr=progress_stderr)
def ssh_command(ip, user, passwd, command): client = paramiko.client.SSHClient() # client.load_host_keys('/home/justin/.ssh/known_hosts') client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) client.connect(ip, username=user, password=passwd) ssh_session = client.get_transport().open_session() if ssh_session.active: ssh_session.exec_command(command) print ssh_session.recv(1024) return
def checkhostSSHStatus(self, HOST, USER, PASS): client = paramiko.SSHClient() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) try: client.connect(HOST, username=USER, password=PASS, timeout=10) print "SSH connection to %s established" % HOST client.close() print "Logged out of device %s" % HOST return "SSH established successfully" except: return "SSH failed"
def killVLCStream(self): """ Sends a command to the pi to kill streaming """ try: print("Connecting to streaming pi") client = SSHClient() client.set_missing_host_key_policy(AutoAddPolicy) client.connect('192.168.1.69', port=22, username='******', password='******') client.exec_command('pkill vlc') print("Killed pi's vlc stream") except Exception as e: print("Error sending commands to pi: ", str(e))
def connect(self): instances = self.manager.list_worker_instances() addrs = [_get_external_ip(instance) for instance in instances] hosts = { ip: instance["name"] for ip, instance in zip(addrs, instances) } clients = {} for ip, name in hosts.items(): client = paramiko.client.SSHClient() client.set_missing_host_key_policy(_IgnoreMissingHostKeys) client.connect(hostname=ip) clients[name] = client return clients
def test_004_check_updated_status_of_DCA_and_ATP(self): sleep(10) client = paramiko.SSHClient() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) privatekeyfile = os.path.expanduser('~/.ssh/id_rsa') mykey = paramiko.RSAKey.from_private_key_file(privatekeyfile) client.connect(config.grid_vip, username='******', pkey = mykey) data="cat /infoblox/var/fastpath_status\n" stdin, stdout, stderr = client.exec_command(data) stdout=stdout.read() print(stdout) if 'dca_status: failure' in stdout and 'atp_status: failure' in stdout : print("Success : Status of DCA and ATP are rightly updated for fastpath") else: print("Failure : Status of DCA and ATP are rightly updated for fastpath") client.close() assert False
def test_005_check_fp_failure_flag(self): client = paramiko.SSHClient() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) privatekeyfile = os.path.expanduser('~/.ssh/id_rsa') mykey = paramiko.RSAKey.from_private_key_file(privatekeyfile) client.connect(config.grid_vip, username='******', pkey = mykey) stdin, stdout, stderr = client.exec_command("ls /infoblox/var/flags") result=stdout.read() print(len(result)) print(result) if 'fp_failure' in result: print("Success: fp_failure flag is part of /infoblox/var/flags directory") assert True else: print("Failue: fp_failure flag is part of /infoblox/var/flags directory") assert False client.close()
def test_001_validating_sppc_present_in_dns_view(self): client = paramiko.SSHClient() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) privatekeyfile = os.path.expanduser('~/.ssh/id_rsa') mykey = paramiko.RSAKey.from_private_key_file(privatekeyfile) client.connect(config.grid_vip, username='******', pkey=mykey) data = "cat /infoblox/var/named_conf/dns_cache_acceleration.json" stdin, stdout, stderr = client.exec_command(data) stdout = stdout.read() print(stdout) data = json.loads(stdout) if "sppc" in data["dca_config"]["1"]: print("Success : DNS sppc present in First dns view") assert True else: print("Failed: DNS sppc present in more than one dns views") assert False
def run_command(self, host, command, username=None, port=None, progress_stderr=None): if port is None: port = 22 client = paramiko.SSHClient() client.set_missing_host_key_policy(AutoAcceptPolicy()) client.connect(host, username=username, port=port, **self.ssh_kwargs) channel = client.get_transport().open_session() channel.exec_command(*command) from dulwich.client import ParamikoWrapper return ParamikoWrapper( client, channel, progress_stderr=progress_stderr)
def ssh_attempt_connect(nodename, ssh_key): client = paramiko.client.SSHClient() client.set_missing_host_key_policy(IgnoreMissingKeyPolicy()) user = '******' port = 22 logger.debug("Connect to \"{nodename}\" as \"{user}\" on port {port}.". format(nodename=nodename, user=user, port=port)) try: client.connect(nodename, port=port, username=user, timeout=SSH_TIMEOUT, pkey=ssh_key, allow_agent=False, look_for_keys=False) except (paramiko.SSHException, socket.timeout, socket.error): raise return client
def clean_db(nodes): with SSHClient() as client: client.connect(nodes[0]) client.run('PYTHONPATH=/root/accounting ' '/root/accounting/bin/test_replica_set.py 300') with tempfile.NamedTemporaryFile(mode='w') as f: f.write( textwrap.dedent('''\ import accounting.db database = accounting.db.connect() print 'Removing database %s.' % database.name database.client.drop_database(database.name) print 'Database %s removed.' % database.name ''')) f.flush() sftp = client.open_sftp() sftp.put(f.name, '/tmp/clean_db.py') client.run('PYTHONPATH=/root/accounting python /tmp/clean_db.py')
def startVLCStream(self): """ Executes the streaming command on the pi and then begins stream """ try: print("Connecting to streaming pi") client = SSHClient() client.set_missing_host_key_policy(AutoAddPolicy) client.connect('192.168.1.69', port=22, username='******', password='******') # If the pi is already streaming, will not start another streaming process client.exec_command( 'if pgrep vlc; then echo "Streaming already started"; else ./vlcTest.sh; fi' ) except Exception as e: print("Error sending commands to pi: ", str(e)) # Delay to allow the streaming to start time.sleep(1) try: # Attempt to start streaming print("Starting VLC stream capture") timenow = datetime.datetime.now().strftime('%m-%w-%y_%H-%M-%S') print('Saving stream to StreamedVideo folder with name: ' + timenow + '.mp4') self.saveStreamThread = threading.Thread(target=lambda: os.system( 'vlc.exe rtsp://' + '192.168.1.69' + ':8080/ --sout=file/mp4:' + 'StreamedVideo\\' # Folder + timenow + '.mp4')) # Filename self.displayStreamThread = threading.Thread( target=lambda: os.system('vlc.exe rtsp://' + '192.168.1.69' + ':8080/')) self.saveStreamThread.start() time.sleep(.1) self.displayStreamThread.start() except Exception as e: print("Error beginning VLC Stream: ", str(e))
def test_006_validation(self): ip_list = [] # #print(os.popen("grid_info "+config.grid_vip).readlines()) # for i in range(1,6): # ip_list.append(os.popen("grid_info "+config.grid_vip).readlines()[i].strip().split(' ')[-5]) # ip_list.append((os.popen("grid_info "+config.grid_vip).readlines()[4].split(' '))[-6]) # while("" in ip_list) : # ip_list.remove("") ip_list.append(config.grid_vip) ip_list.append(config.grid_member1_vip) ip_list.append(config.grid_member2_vip) print(ip_list) for i in ip_list: print(i) print("====================") client = paramiko.SSHClient() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) privatekeyfile = os.path.expanduser('~/.ssh/id_rsa') mykey = paramiko.RSAKey.from_private_key_file(privatekeyfile) client.connect(i, username='******', pkey=mykey) data = "grep -icw 'DTC*initialization' /var/log/messages" stdin, stdout, stderr = client.exec_command(data) stdout = stdout.read() print("output ", stdout) if '0' in stdout: print("Success") client.close() assert True else: print("Failed") client.close() continue assert False
def run_command(self, host, command, username=None, port=None, progress_stderr=None): if not isinstance(command, bytes): raise TypeError(command) # Paramiko needs an explicit port. None is not valid if port is None: port = 22 client = paramiko.SSHClient() policy = paramiko.client.MissingHostKeyPolicy() client.set_missing_host_key_policy(policy) client.connect(host, username=username, port=port, **self.ssh_kwargs) # Open SSH session channel = client.get_transport().open_session() # Run commands channel.exec_command(command) return _ParamikoWrapper( client, channel, progress_stderr=progress_stderr)
def run_command(self, host, command, username=None, port=None, progress_stderr=None): if port is None: port = 22 client = paramiko.SSHClient() client.set_missing_host_key_policy(AutoAcceptPolicy()) client.connect(host, username=username, port=port, **self.ssh_kwargs) channel = client.get_transport().open_session() assert command assert is_shell_safe(command[0]) command = ( command[0] + b' ' + b' '.join( shell_quote(c) for c in command[1:])) channel.exec_command(command) def progress_stderr(s): import sys sys.stderr.write(s.decode("utf-8")) sys.stderr.flush() try: from dulwich.client import ParamikoWrapper except ImportError: from dulwich.contrib.paramiko_vendor import ( _ParamikoWrapper as ParamikoWrapper) return ParamikoWrapper( client, channel, progress_stderr=progress_stderr)
def test_000_check_time_stamp_from_PTOP_log_and_syslog(self): ptop='' sysl='' ptop_ltst='' client = paramiko.SSHClient() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) privatekeyfile = os.path.expanduser('~/.ssh/id_rsa') mykey = paramiko.RSAKey.from_private_key_file(privatekeyfile) client.connect(config.grid_vip, username='******', pkey = mykey) data="ls -ltr /var/log/ptop-* \n" stdin, stdout, stderr = client.exec_command(data) stdout=stdout.readlines() print('\n') ptop_ltst=stdout[-1] ptop_ltst=(ptop_ltst.split(' ')[-1]) print("PTOP log: "+ptop_ltst) client.close() client = paramiko.SSHClient() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) privatekeyfile = os.path.expanduser('~/.ssh/id_rsa') mykey = paramiko.RSAKey.from_private_key_file(privatekeyfile) client.connect(config.grid_vip, username='******', pkey = mykey) data="grep TIME "+ptop_ltst+"\n" stdin, stdout, stderr = client.exec_command(data) res=stdout.readline() hour=res.split(' ')[-1] print("PTOP time stamp: "+res+"->"+res.split(' ')[-2]+"T"+hour.split(':')[-3]) ptop=res.split(' ')[-2]+"T"+hour.split(':')[-3] client.close() client = paramiko.SSHClient() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) privatekeyfile = os.path.expanduser('~/.ssh/id_rsa') mykey = paramiko.RSAKey.from_private_key_file(privatekeyfile) client.connect(config.grid_vip, username='******', pkey = mykey) data="grep TIME /var/log/messages\n" stdin, stdout, stderr = client.exec_command(data) res=stdout.readlines() hour='' for i in res: if ptop in i: hour=i hours=hour.split(' ')[0] sysl=hours.split(':')[-0] print("Sys time stamp : "+hour+"->"+sysl) client.close() if sysl==ptop: print("Success : The time stamp from PTOP log and syslog matches") assert True else: print("Failure : The time stamp from PTOP log and syslog matches") assert False
def open_auth_log(hostname, *args, **kwargs): """Open a readonly file-like object that reads /etc/log/auth.log on `hostname`. :param hostname: the server to connect to :param args: extra args to pass to SSHClient.connect() :param kwargs: extra keyword args to pass to SSHClient.connect() :return: TemporaryFile object with log file contents """ # Initiate connection client = paramiko.client.SSHClient() client.load_system_host_keys() kwargs["compress"] = kwargs.get("compress", True) client.connect(hostname, *args, **kwargs) # Copy file temp = tempfile.TemporaryFile() sftp = client.open_sftp() sftp.getfo("/var/log/auth.log", temp, print_download_progress) sftp.close() print() # Seek back to beginning of file for reading temp.seek(0) return temp
import sys import Crypto import paramiko.client as client sys.modules['Crypto'] = Crypto hostName = "10.13.254.40" uName = "Pi" pWord = "Raspberry" client = client.SSHClient() client.load_system_host_keys() client.connect(hostname=hostName, port=22, username=uName, password=pWord) response = client.exec_command('ls') print response
def get_sshclient(host): client = paramiko.SSHClient() client.load_system_host_keys() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) client.connect(hostname=host, username=None, password=None) return client
current_os = platform.system().lower() if current_os == "windows": param = "-n" output = "\Desktop\output.txt" homedir = os.environ['USERPROFILE'] else: param = "-c" output = "/Desktop/output.txt" homedir = os.environ['HOME'] for ip in dump: print(ip) client = SSHClient() client.set_missing_host_key_policy(AutoAddPolicy()) client.connect(ip, username='******', password='******') stdin, stdout, stderr = client.exec_command(f'ping -c 3 x.x.x.x') res = f'STDOUT: |{ip}| {stdout.read().decode("utf8")}' print(f'STDERR: {stderr.read().decode("utf8")}') file = open(f'hotexamples_com/Desktop/output.txt', 'a') file.write(res) file.close() # Because they are file objects, they need to be closed stdin.close() stdout.close() stderr.close() # Close the client itself client.close()
def init_paramiko(): # needed parameters for connection port = 22 hostname = 'beaglebone' username = '******' password = '******' ############################## #determine if we are in linux or windows try: import termios import tty has_termios = True except ImportError: has_termios = False try: global chan client = paramiko.SSHClient() client.load_system_host_keys() client.set_missing_host_key_policy(paramiko.WarningPolicy()) print("*** Connecting...") client.connect(hostname, port, username, password) chan = client.invoke_shell() print(repr(client.get_transport())) output.insert("end-1c", '*** SSH Connection to BB_AI stablished ***\n') chan.send('python3 bb.py\n') print("*** SSH Connection to BB_AI stablished!\n") #creating the log file #if the file exist if path.exists("log_gui.txt"): #then append to the existing file file = open("log_gui.txt", "+a") else: #create a new one file = open("log_gui.txt", "+w") ########################################################################### if has_termios: import select oldtty = termios.tcgetattr(sys.stdin) try: tty.setraw(sys.stdin.fileno()) tty.setcbreak(sys.stdin.fileno()) chan.settimeout(0.0) while True: r, w, e = select.select([chan, sys.stdin], [], []) if chan in r: try: c = 0 x = u(chan.recv(1024)) if len(x) == 0: sys.stdout.write("\r\n*** Done ***\r\n") chan.close() client.close() break #strip non useful info if c <= 1: data = data[400:] c += 1 if str(data).startswith('debian@beaglebone:~$'): data = str(data).replace( 'debian@beaglebone:~$ python3 bb.py', ' ') if str(data).startswith('python3'): data = str(data).replace('python3 bb.py', ' ') if start_parsing: # Parse the sensor values if 'Sensor' in str(data): #change the box color to red to indicate warning if float(data[16:19]) > 1.0: box1["bg"] = "#fb9898" #light red box1["fg"] = "black" box1.insert(END, "") #box_color_change("red", "black", "box1") box1.delete(1.0, END) box1.insert('1.0', data[16:19]) # box2.delete(1.0, END) box2.insert("1.0", data[20:23]) # box3.delete(1.0, END) box3.insert("1.0", data[24:27]) # box4.delete(1.0, END) box4.insert("1.0", data[28:31]) # box5.delete(1.0, END) box5.insert("1.0", data[32:35]) # box6.delete(1.0, END) box6.insert("1.0", data[36:39]) # ''' box7.delete(1.0, END) box7.insert("1.0",data[40:43]) # box8.delete(1.0, END) box8.insert("1.0",data[44:47]) # box9.delete(1.0, END) box9.insert("1.0",data[40:43]) # box10.delete(1.0, END) box10.insert("1.0",data[44:47]) # box11.delete(1.0, END) box11.insert("1.0",data[48:51]) # box12.delete(1.0, END) box12.insert("1.0",data[52:55]) # box13.delete(1.0, END) box13.insert("1.0",data[56:59]) # box14.delete(1.0, END) box14.insert("1.0",data[60:63]) # box15.delete(1.0, END) box15.insert("1.0",data[64:67]) # box16.delete(1.0, END) box16.insert("1.0",data[68:71]) ''' if 'Sensor' in str(x): continue output.insert("end-1c", x) output.see("end") #for testing #print(x, end= '\r', flush= True) #sys.stdout.write(x) #sys.stdout.flush() except socket.timeout: pass if not ON: return "Exiting GUI" #writing in console ''' if sys.stdin in r: x = sys.stdin.read(1) if len(x) == 0: break chan.send(x) ''' finally: termios.tcsetattr(sys.stdin, termios.TCSADRAIN, oldtty) # if we are in a windows based environment else: def writeall(sock): count = 0 while True: data = sock.recv(9999).decode('utf8') file.write(data + '\n') if not data or not ON: sys.stdout.write("\r\n*** Done ***\r\n\r\n") sys.stdout.flush() file.close() chan.close() client.close() break #strip non useful info if count <= 1: data = data[400:] count += 1 if str(data).startswith('debian@beaglebone:~$'): data = str(data).replace( 'debian@beaglebone:~$ python3 bb.py', ' ') if str(data).startswith('python3'): data = str(data).replace('python3 bb.py', ' ') if start_parsing: # Parse the sensor values if 'Sensor' in str(data): #change the box color to red to indicate warning if float(data[16:19]) > 1.0: box1["bg"] = "#fb9898" #light red box1["fg"] = "black" box1.insert(END, "") box1.delete(1.0, END) box1.insert('1.0', data[16:19]) # if float(data[20:23]) > 1.0: box2["bg"] = "#fb9898" #light red box2["fg"] = "black" box2.insert(END, "") box2.delete(1.0, END) box2.insert("1.0", data[20:23]) # if float(data[24:27]) > 1.0: box3["bg"] = "#fb9898" #light red box3["fg"] = "black" box3.insert(END, "") box3.delete(1.0, END) box3.insert("1.0", data[24:27]) # if float(data[28:31]) > 1.0: box4["bg"] = "#fb9898" #light red box4["fg"] = "black" box4.insert(END, "") box4.delete(1.0, END) box4.insert("1.0", data[28:31]) # if float(data[32:35]) > 1.0: box5["bg"] = "#fb9898" #light red box5["fg"] = "black" box5.insert(END, "") box5.delete(1.0, END) box5.insert("1.0", data[32:35]) # if float(data[36:39]) > 1.0: box6["bg"] = "#fb9898" #light red box6["fg"] = "black" box6.insert(END, "") box6.delete(1.0, END) box6.insert("1.0", data[36:39]) # ''' box7.delete(1.0, END) box7.insert("1.0",data[40:43]) # box8.delete(1.0, END) box8.insert("1.0",data[44:47]) # box9.delete(1.0, END) box9.insert("1.0",data[40:43]) # box10.delete(1.0, END) box10.insert("1.0",data[44:47]) # box11.delete(1.0, END) box11.insert("1.0",data[48:51]) # box12.delete(1.0, END) box12.insert("1.0",data[52:55]) # box13.delete(1.0, END) box13.insert("1.0",data[56:59]) # box14.delete(1.0, END) box14.insert("1.0",data[60:63]) # box15.delete(1.0, END) box15.insert("1.0",data[64:67]) # box16.delete(1.0, END) box16.insert("1.0",data[68:71]) ''' if 'Sensor' in str(data): continue output.insert("end-1c", data) output.see("end") #for testing #print(data, end= '\r', flush= True) if not ON: return "Exiting GUI" writer = threading.Thread(target=writeall, args=(chan, )) writer.start() except Exception as e: print("*** Caught exception: %s: %s" % (e.__class__, e)) traceback.print_exc() try: client.close() except: pass sys.exit(1)
# cf. https://github.com/PyCQA/bandit/blob/d5f8fa0d89d7b11442fc6ec80ca42953974354c8/examples/paramiko_injection.py import paramiko from paramiko import client client = paramiko.client.SSHClient() # this is safe # ok client.connect('somehost') # this is not safe # ruleid:paramiko-exec-command client.exec_command('something; really; unsafe') client2 = client.SSHClient() client2.connect("somewhere-out-there") # ruleid:paramiko-exec-command client2.exec_command("ls -r /")
def add_alias_member(ip_address): exp = "\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}" r = re.search(exp, ip_address) """ Make sure we receive a valid IP address """ if r is None: logger.error("Did not receive a valid IP address") return False # Connect to WatchGuard, set disable looking for keys # If you're using pubkey auth, you'll need to change some params here try: client.connect(WATCHGUARD_IP, port=WATCHGUARD_PORT, username=WATCHGUARD_USER, password=WATCHGUARD_PASSWORD, allow_agent=False, look_for_keys=False) logger.info("Connect to WatchGuard") except Exception as e: print("Error connecting to WatchGuard: {}".format(str(e))) return False # Invoke a shell that we can work with shell = client.invoke_shell() # Change to configure mode shell.send("configure\n") sleep(2) # Change to policy mode shell.send("policy\n") sleep(2) # Add the IP to our alias containing blocked IPs shell.send("alias {} host-ip {} \n".format(WATCHGUARD_ALIAS, ip_address)) sleep(2) shell.send("apply\n") sleep(2) # This response is a bytes-object response = shell.recv(2024) logger.info(f"Response from WatchGuard\n: {str(response)}") # Exit policy mode shell.send("exit\n") sleep(2) # Exit configure mode shell.send("exit\n") sleep(2) # Exit WatchGuard CLI shell.send("exit\n") sleep(2) # Close the shell we invoked shell.close() # Close the connection client.close() logger.info("Closed connection to WatchGuard") return True
def _gerrit_feedback(_args, _errors, _warnings, _blockage, message): # pylint: disable = too-many-locals import json # work around from https://github.com/paramiko/paramiko/pull/861 # for bug https://github.com/paramiko/paramiko/issues/1068 when # GSSAPI is installed by Ansible sys.modules['gssapi'] = None import paramiko.client if _args.gerrit_from_jenkins: logging.info("Getting gerrit info from Jenkins environment") scheme = os.environ['GERRIT_SCHEME'] if scheme != 'ssh': logging.error('%s: GERRIT_SCHEME unsupported', scheme) host = os.environ['GERRIT_HOST'] port = int(os.environ['GERRIT_PORT']) change_number = int(os.environ['GERRIT_CHANGE_NUMBER']) patchset_number = int(os.environ['GERRIT_PATCHSET_NUMBER']) ssh_user = os.environ['SSH_USER'] else: logging.info("Getting gerrit info from cmdline") host = _args.gerrit_ssh_host port = int(_args.gerrit_ssh_port) change_number = _args.gerrit_change_number patchset_number = _args.gerrit_patchset_number ssh_user = _args.gerrit_ssh_user params = {} if ssh_user: params['username'] = ssh_user client = paramiko.client.SSHClient() client.load_system_host_keys() client.connect(host, port, **params) data = dict(labels={}, ) if _warnings > 0: data['labels']['Code-Review'] = -1 if _errors == 0: data['labels']['Verified'] = 1 else: data['labels']['Verified'] = -1 if _blockage > 0: # No verification if missing tools print(("W: 'Verified %d' vote skipped as some tools are missing " "and can't check it all" % data['labels']['Verified'])) del data['labels']['Verified'] if message and message != "": if _args.url: cut_msg = "...\n<cut oversized report, more at %s>" % _args.url else: cut_msg = "...\n<cut oversized report>" cut_len = len(cut_msg) if len(message) > _args.gerrit_message_limit: message = message[:_args.gerrit_message_limit - cut_len] \ + cut_msg data['message'] = message stdin, stdout, stderr = client.exec_command( 'gerrit review --json %d,%d' % (change_number, patchset_number), bufsize=-1) stdin.write(json.dumps(data)) stdin.flush() stdin.channel.shutdown_write() output = str(stdout.read(), encoding = 'utf-8') \ + str(stderr.read(), encoding = 'utf-8') if output: logging.error("gerrit review output: %s", output)
def init_paramiko(): # needed parameters for connection port = 22 hostname = 'beaglebone' username = '******' password = '******' #For testing with usb #hostname = '192.168.7.2' ############################## #determine if we are in linux or windows try: import termios import tty has_termios = True except ImportError: has_termios = False try: global chan client = paramiko.SSHClient() client.load_system_host_keys() client.set_missing_host_key_policy(paramiko.WarningPolicy()) print("*** Connecting...") client.connect(hostname, port, username, password) chan = client.invoke_shell() print(repr(client.get_transport())) output.insert("end-1c", '*** SSH Connection to BB_AI stablished ***\n\n') global flag_1 flag_1 = True # This flag is created with the objective that Automatic Shutdown button can only # work if an SSH connection is actually stablished #chan.flush() chan.send('python3 multiprocessingbb.py\n') print("*** SSH Connection to BB_AI stablished!\n") #creating the log file #if the file exist if path.exists("log_gui.txt"): #then append to the existing file file = open("log_gui.txt", "+a") else: #create a new one file = open("log_gui.txt", "+w") ########################################################################### if has_termios: import select oldtty = termios.tcgetattr(sys.stdin) try: tty.setraw(sys.stdin.fileno()) tty.setcbreak(sys.stdin.fileno()) chan.settimeout(0.0) while True: r, w, e = select.select([chan, sys.stdin], [], []) if chan in r: try: c = 0 x = u(chan.recv(1024).decode('utf8')) if len(x) == 0: sys.stdout.write("\r\n*** Done ***\r\n") chan.close() client.close() break #strip non useful info #strip non useful info with a more specific approach is better if 'The programs' in str(x) or 'GNU/Linux' in str(x) \ or 'exact distribution' in str(x) or '@beaglebone' in str(x) \ or 'python3' in str(x) or 'bb.py' in str(x): length = len(x) x = x[length:] if 'PORTLAND' in str(x): global sig sig = True # Once done slicing the greeting section lest get State status #global sig global count if sig: if count >= 1: chan.send('status\n') #global sig sig = False #global count count += 1 if 'State :' in str(x) or 'tate :' in str(x): global state_preview state_preview = x[8:].replace('[K', '') if start_parsing: box18.delete(1.0, END) box18.insert("1.0", state_preview) # Parse the sensor values if 'Sensor' in str(x): #change the box color to red to indicate warning #for testing #x = x.split(' ') x = x + ' 0 1 2 1 1 2 1 0 0' s_val = x.replace('\x1b[F\r', '').split(' ') #for testing only (for the case where we get less than 30 sensor values) if not len(s_val) == 41: while len(s_val) < 41: s_val.insert(32, '0') s_val = s_val[2:19] + s_val[32:41] s_val = map(float, s_val) s_val = list(s_val) obj_list = [box1, box2, box3, box4, box5, box6, box7, box8, box9, box10, box11, box12, box13, box14, box15, box16, \ box17, c1, c2, c3, c4, c5, c6, c7, c8, c9] lenq = len(s_val) for index in range(len(s_val)): for index in range(0, 17): if s_val[index] > 1: #change the box color when outside valid range box_color_change( obj_list[index], "#fb9898") # if the sensor value is withing the spected range then keep box color yellow obj_list[index].delete(1.0, END) obj_list[index].insert( '1.0', s_val[index]) for index in range(17, 26): # if the valve is turned ON then light up GREEN if s_val[index] == 1: valve_position_color( obj_list[index], "#58df52") # if the valve is turned OFF then light up BLUE elif s_val[index] == 0: valve_position_color( obj_list[index], "blue") # if there is an error with the valve light up RED elif s_val[index] == 2: valve_position_color( obj_list[index], "red") if 'Sensor' in str(x): continue x = x.replace('[K', '') output.insert("end-1c", x) output.see("end") #for testing #print(x, end= '\r', flush= True) #sys.stdout.write(x) #sys.stdout.flush() except socket.timeout: pass if not ON: return "Exiting GUI" #writing in console ''' if sys.stdin in r: x = sys.stdin.read(1) if len(x) == 0: break chan.send(x) ''' finally: termios.tcsetattr(sys.stdin, termios.TCSADRAIN, oldtty) ############################################################################# # if we are in a windows. ############################################################################# else: #global count def writeall(sock): global sig_to_resend while True: data = ' ' data = sock.recv(9999).decode('utf8') file.write(data + '\n') if not data or not ON: sys.stdout.write("\r\n*** Done ***\r\n\r\n") sys.stdout.flush() file.close() chan.close() client.close() break #Make sure we always have only one data packet if 'Sensor' in data: spl = data.split('\r') #splitting the sensor values and adding the to a FIFO Queue for index in range(len(spl)): if len(spl[index]) > 0: q.put(spl[index]) #for testing #print(data, end= '\r', flush= True) #strip non useful info with a more specific approach is better if 'The programs' in str(data) or 'GNU/Linux' in str(data) \ or 'exact distribution' in str(data) or '@beaglebone' in str(data) \ or 'python3' in str(data) or 'bb.py' in str(data): length = len(data) data = data[length:] if 'PORTLAND' in str(data): global sig sig = True # Once done slicing the greeting section lest get State status #global sig global count if sig: #wait till next time around if count >= 1: chan.send('status\n') #global sig sig = False #sig_to_resend = True #global count count += 1 #for testing #print(data) if 'State :' in str(data) or 'tate :' in str(data): global state_preview index = data.find(':') if not index == -1: state_preview = str(data[index + 1:]).replace( '[K', '').replace('\x1b', ' ') #for testing print(state_preview) else: #state_preview = str(data[8:]).replace('[K', '').replace('\x1b', ' ') pass if start_parsing: #Always display the current state in the P&ID window box18.delete(1.0, END) box18.insert("1.0", state_preview) # Parse the sensor values if 'Sensor values:' in str(data): # for testing (prints sensor values ) #print(data, end= '\r', flush= True) #change the box color to red to indicate warning #for testing #x = x.split(' ') data = q.get() index2 = data.find(':') if not index == -1: data = data[index2 + 2:].replace('\x1b[F', '') data = data + ' 0 1 2 1 1 2 1 0 0' s_val = data.split(' ') #for testing only (for the case where we get less than 30 sensor values) if not len(s_val) == 39: while len(s_val) < 39: s_val.insert(30, '0') s_val = s_val[0:17] + s_val[30:39] mapping = map(float, s_val) s_val = list(mapping) obj_list = [box1, box2, box3, box4, box5, box6, box7, box8, box9, box10, box11, box12, box13, box14, box15, box16, \ box17, c1, c2, c3, c4, c5, c6, c7, c8, c9] lenq = len(s_val) for index in range(len(s_val)): for index in range(0, 17): if s_val[index] > 1: #change the box color when outside valid range box_color_change( obj_list[index], "#fb9898") # if the sensor value is withing the spected range then keep box color yellow obj_list[index].delete(1.0, END) obj_list[index].insert('1.0', s_val[index]) for index in range(17, 26): # if the valve is turned ON then light up GREEN if s_val[index] == 1: valve_position_color( obj_list[index], "#58df52") # if the valve is turned OFF then light up BLUE elif s_val[index] == 0: valve_position_color( obj_list[index], "blue") # if there is an error with the valve light up RED elif s_val[index] == 2: valve_position_color( obj_list[index], "red") #format the data back to distinguis from the screen we want to print to data = f'Sensor values: {data}' if 'Sensor' in str(data): continue output.insert("end-1c", str(data).replace('\x1b[K', ' ')) output.see("end") if not ON: return "Exiting GUI" writer = threading.Thread(target=writeall, args=(chan, )) #writer.daemon = True writer.start() except Exception as e: print("*** Caught exception: %s: %s" % (e.__class__, e)) traceback.print_exc() if '[Errno 11001] getaddrinfo failed' == str(e): output.insert("end-1c", f' Error connecting to BB_AI.\n') elif '[WinError 10060]' in str(e): output.insert("end-1c", f' Error connecting to BB_AI.\n') try: client.close() except: pass sys.exit(1)
def bootstrapped(nodes): with SSHClient() as client: client.connect(nodes[0]) print('Bootstrapping system.') client.run('PYTHONPATH=/root/accounting ' '/root/accounting/bin/bootstrap.py')