transport = paramiko.Transport((host,port)) transport.connect(username=user_,password=pass_) sftp = paramiko.SFTPClient.from_transport(transport) #download #filepath = '' #localpath= '' #sftp.get(filepath,localpath) #upload #serverpath = '' #localpath= '' #sftp.put(serverpath,localpath) chan = ssh_client.invoke_shell() stdin = chan.makefile('wb') stdout = chan.makefile('rb') #for testing #stdin.write('mkdir c') filepaths=['c/fileio.c', 'c/fileio.h', 'c/min.c', 'c/max.c', 'c/rand.c'] #for i in filepaths: # sftp.put(i, i) sftp.mkdir("c") sftp.put('c/fileio.c','c/fileio.c') sftp.put('c/fileio.h','c/fileio.h') sftp.put('c/min.c','c/min.c') sftp.put('c/max.c','c/max.c') sftp.put('c/rand.c','c/rand.c')
def connect(self, host, username, password="", port=""): try: client = SSHClient() client.load_system_host_keys() client.set_missing_host_key_policy(AutoAddPolicy()) client.connect( host, username=username, password=password, look_for_keys=True, timeout=5000, ) self.channel = client.invoke_shell() detectedDevice = (self.channel.recv(len(self.deviceHostname) + 2).decode().strip()) if detectedDevice != "{0} #".format( self.deviceHostname) and detectedDevice != "{0} $".format( self.deviceHostname): self.error = ( "Device detected name does not match the device name provided." ) self.disconnect return None return client except Exception as e: self.error = e return None
def vm_create_eva_access(host, port=22, password='******', accesses=15): """Summary Args: host (TYPE): Description port (int, optional): Description password (str, optional): Description accesses (int, optional): Description """ data = 'NB_LINES=' + accesses client = SSHClient() # use the paramiko SSHClient client.set_missing_host_key_policy( AutoAddPolicy()) # automatically add SSH key try: client.connect(host, port, username='******', password=password) except AuthenticationException: print('*** Failed to connect to {}:{}'.format(host, port)) channel = client.invoke_shell() while channel.recv_ready() is False: sleep(3) # OXE is really slow on mtcl connexion stdout = channel.recv(4096) channel.send('cat >> /usr3/mao/eva.access << EOF\n' + data + '\nEOF\n') while channel.recv_ready() is False: sleep(0.5) stdout += channel.recv(1024) # print(stdout.decode(encoding='UTF-8')) channel.close() client.close()
def oxe_netdata_get(host, pattern, port=22, password='******'): """Summary Args: host (TYPE): Description pattern (TYPE): Description port (int, optional): Description password (str, optional): Description Returns: TYPE: Description """ client = SSHClient() # use the paramiko SSHClient client.set_missing_host_key_policy( AutoAddPolicy()) # automatically add SSH key try: client.connect(host, port, username='******', password=password) except AuthenticationException: print('*** Failed to connect to {}:{}'.format(host, port)) # stdout, stdin, stderr = client.exec_command('sed -n -e \'s/^' + pattern + '=\([^;][^;]*\).*/\\1/p\' -e \'s/.*;' + # pattern + '=\([^;][^;]*\).*/\\1/p\' /usr/netadm/data/netdata\n') channel = client.invoke_shell() while channel.recv_ready() is False: sleep(3) # OXE is really slow on mtcl connexion stdout = channel.recv(4096) channel.send('cat /usr/netadm/data/netdata\n') while channel.recv_ready() is False: sleep(0.5) stdout = channel.recv(4096) channel.close() client.close() find = compile(pattern + '=.*').findall( stdout.decode('utf-8'))[0].split('=')[1] return find
def oxe_reboot(host, port, password, swinst_password): """Reboot OXE Call Server Args: host (TYPE): Description port (TYPE): Description password (TYPE): Description swinst_password (TYPE): Description """ # connect OXE through SSH and execute 'rainbowagent -v' client = SSHClient() # use the paramiko SSHClient client.set_missing_host_key_policy( AutoAddPolicy()) # automatically add SSH key try: client.connect(host, port, username='******', password=password) except AuthenticationException: print('*** Failed to connect to {}:{}'.format(host, port)) channel = client.invoke_shell() while channel.recv_ready() is False: sleep(3) # OXE is really slow on mtcl connexion stdout = channel.recv(4096) channel.send('reboot\n') while channel.recv_ready() is False: sleep(1) stdout += channel.recv(1024) channel.send(swinst_password + '\n') while channel.recv_ready() is False: sleep(0.5) stdout += channel.recv(1024) # pprint.pprint(stdout) channel.close() client.close()
def startConnection(self): """ connection to remote server can launch a thread checking every minute your mailbox... """ #if not self.directory:return #self.parent().close() self.close() client = SSHClient() client.set_missing_host_key_policy(AutoAddPolicy()) try: client.connect(str(self.host.text()), username=str(self.username.text()), password=str(self.password.text())) except SSHException: qApp.instance().showErrorMessage("Error", "The ssh session could not be established") except AuthenticationException: qApp.instance().showErrorMessage("Error","Authentication failed") except BadHostKeyException: qApp.instance().showErrorMessage("Error", "the server's host key could not be verified") sftpCp = self.cleaningRepository(client) if sftpCp: sftp = client.open_sftp() self.sftpCopying(sftp) sftp.close() else: self.retrieveDirTree(c, out) self.makeRScript(client) self.makeShellScript(client) if self.interactiveSession.isChecked(): import interactive print ('invoking a shell') chan = client.invoke_shell() chan.send('bash\n') interactive.interactive_shell(chan) chan.close() else: self.launchCommand(client) client.close()
def update_router(): for router in request.json["routers"]: ssh = SSHClient() ssh.set_missing_host_key_policy(AutoAddPolicy()) ssh.connect(router["ip"], router["port"], router["user"], router["password"]) ssh_command = ssh.invoke_shell() ssh_command.send("configure terminal\n") ssh_command.send("interface {}\n".format(router["interface"])) time.sleep(1) # output = ssh_command.recv(5000) # print(output) ssh_command.send("bandwidth {}\n".format(request.json["bandwidh"])) time.sleep(1) # output = ssh_command.recv(5000) # print(output) ssh_command.send("no shutdown\n") time.sleep(1) # output = ssh_command.recv(5000) # print(output) ssh_command.send("exit\n") ssh_command.send("exit\n") time.sleep(1) # output = ssh_command.recv(5000) # print(output) # ssh_command.send("copy running-config startup-config\n") ssh.close() return make_response({"message": "complete"})
class Main(): def __init__(self): self.server = "192.168.1.250" self.user = "******" self.pw = getpass.getpass("Password for \"fisk\" on the remote host:") self.initSSH("ask") self.execRemoteMount() input("Check volume mount then press enter") self.execRemoteClose() self.ssh.close() def sendData(self, data): while not self.channel.send_ready(): time.sleep(1) self.channel.send(str(data)) def recvData(self, size): while not self.channel.recv_ready(): time.sleep(1) data = self.channel.recv(size) return data def execRemoteClose(self): stdin, stdout, stderr = self.ssh.exec_command("sudo /home/fisk/Projects/sshs/sshs close") def execRemoteMount(self): stdin, stdout, stderr = self.ssh.exec_command("sudo /home/fisk/Projects/sshs/sshs open /media/fisk/ARCHIVE1/Safe/onOLEcNsojuin.bin --key /media/fisk/ARCHIVE1/safe.keyfile") output = stdout.readlines() print(output) def initSSH(self, auto_add="no"): self.ssh = SSHClient() self.ssh.set_missing_host_key_policy(AutoAddPolicy()) self.ssh.connect(self.server, username=self.user, password=self.pw) self.channel = self.ssh.invoke_shell()
def ssh_cli_command(ipadd, user, pwd, namafile): client = SSHClient() client.set_missing_host_key_policy(AutoAddPolicy()) try: client.connect(ipadd, username=user, password=pwd) remote_shell = client.invoke_shell() except AuthenticationException: print("Authentication failed, please verify your credentials !") return False except SSHException as sshException: print("Unable to establish SSH connection: %s" % sshException) return False except socket.error: print("Unable to connect to host " + ipadd) return False try: f = open(namafile, "r") except: print("File " + namafile + " is not found !") return False for line in f: if (len(line) > 1): remote_shell.send(line.strip() + "\n") while not remote_shell.recv_ready(): time.sleep(.1) output = remote_shell.recv(10000) print(output.decode("ascii")) f.close() client.close() return True
class SSHEngine(BaseTransportEngine): def __init__(self, hostname, username, password, timeout=.5): self._client = SSHClient() self._client.set_missing_host_key_policy(AutoAddPolicy()) self._client.connect(hostname, username=username, password=password) self._shell = self._client.invoke_shell() self._shell.settimeout(timeout) self.send_command_get_output(' ') def _send_command(self, command, end): self._shell.send(command + end) def _get_output(self, buffer_size, return_as_list): data = '' while True: try: data += bytes.decode(self._shell.recv(buffer_size)) except SocketTimeout: break if return_as_list: return data.splitlines() else: return data def close_connection(self): self._client.close()
def ssh_cfg(self, host, username, password, port=22, ignore_confirmation=False): if ignore_confirmation is not True: print(self.__repr__()) self.print_cfg() print("\n") confirm = input("Type 'APPLY' to confirm configuration apply") if confirm != "APPLY": print("Not applying configuration.") return None cmd_list = self.export_cfg(remove_indent=True) # Do actual apply client = SSHClient() client.set_missing_host_key_policy(AutoAddPolicy()) # Make connection and create shell. client.connect(host, port, username, password) shell = client.invoke_shell() for cmd in cmd_list: _, stdout, stderr = client.exec_command(cmd) print("== {} ==:\n{}{}".format(cmd, stdout, stderr)) print("\n") print("\n") print("Applied configuration via SSH.")
def Start_Async_Show(self, host, user, passwd): ssh = SSHClient() ssh.load_system_host_keys() ssh.set_missing_host_key_policy(client.AutoAddPolicy()) ssh.connect(host, port=22, username=user, password=passwd, timeout=30) channel = ssh.invoke_shell() channel.exec_command("show router bgp routes | match Routes") ssh.close()
def run(self): try: # run a command and wait for it to finish def run(command): _, stdout, _ = ssh.exec_command(command) stdout.channel.recv_exit_status() # send the webapp a textual progress update listener = Listener() def log(text): listener.publish(('project', self.project.name, 'deploy', 'status'), { 'text': text }) # prevent accidentally deploying on the server itself # (this doesn't prevent deploying to the server's public # IP address, so there's still a security problem here) if self.host in ['127.0.0.1', '0.0.0.0']: raise Exception('you\'re trying to deploy to the server!') # create temporary build file path = os.path.join(tempfile.mkdtemp(), 'deploy.launch') xml = roslaunch_xml_for_file(self.project.project_file_path, self.remote_deploy_path) open(path, 'w').write(xml) log('Created file: deploy.launch') # create a ssh session log('Connecting to %s@%s...' % (self.user, self.host)) ssh = SSHClient() ssh.load_system_host_keys() ssh.set_missing_host_key_policy(AutoAddPolicy()) ssh.connect(self.host, username=self.user, password=self.password) log('Connected to remote machine') # clean the deploy location run('rm -fr %s' % self.remote_deploy_path) run('mkdir -p %s' % self.remote_deploy_path) log('Cleaned deploy location') # copy the launch file over scp = SCPClient(ssh.get_transport()) scp.put(path, remote_path=self.remote_deploy_path) log('Copied file: deploy.launch') # run the file command = 'cd %s && roslaunch deploy.launch' % self.remote_deploy_path channel = ssh.invoke_shell() channel.send(command + '\nexit\n') log('Ran command: roslaunch deploy.launch') # wait for the command to finish import time while not self.die: time.sleep(0.1) except: import traceback log('Exception:\n' + traceback.format_exc()) ssh.close() log('Connection was closed')
class SshShell(object): class Error(Exception): def __init__(self, message: str): self.message = message def __init__(self, host, user, passwd=None, port=22): self.client = SSHClient() self.client.set_missing_host_key_policy(AutoAddPolicy()) self.client.connect( host, port=port, username=user, password=passwd, ) def exec_command(self, cmd: str): log(log.DEBUG, "RemoteShell: command [%s]", cmd) if not self.client: return None stdin, stdout, stderr = self.client.exec_command(cmd) error_lines = stderr.readlines() if error_lines: log(log.ERROR, "RemoteShell: error exec command [%s]", cmd) error_message = "\n".join( [line.strip("\n\r") for line in error_lines]) raise RemoteShell.Error(error_message) result = "\n".join([line.strip("\n\r") for line in stdout.readlines()]) log(log.DEBUG, "RemoteShell: result [%s]", result) return result def send_command(self, cmd): log(log.DEBUG, "RemoteShell: command [%s]", cmd) BUFFER_SIZE = 1024 with self.client.get_transport().open_session() as channel: channel.get_pty(width=1024) channel.settimeout(5) channel.exec_command(cmd + "\n") if channel.recv_stderr_ready(): log(log.ERROR, "RemoteShell: Error") data = channel.recv_stderr(BUFFER_SIZE) error_message = data.decode() raise RemoteShell.Error(error_message) out_message = "" while True: data = channel.recv(BUFFER_SIZE) if not data: break out_message += data.decode() return out_message def run_shell_command(self, cmd): with self.client.invoke_shell() as chan: while chan.recv_ready(): time.sleep(1) chan.recv(1024) time.sleep(1) chan.send(f"{cmd}\n") return chan.recv(1024).decode()
class SSHConnection: attrs = "open", "get", "put", "chmod", "exec_command", "mkdir", "rmdir" def __init__(self, hostname, username, password, queue): self.hostname, self.username, self.password = hostname, username, password self.queue = queue from paramiko import SSHClient, AutoAddPolicy self.client = SSHClient() self.client.set_missing_host_key_policy(AutoAddPolicy()) def __enter__(self): self.client.connect(hostname=self.hostname, username=self.username, password=self.password) self.channel = self.client.invoke_shell() self.stdin = self.channel.makefile("w") self.stdout = self.channel.makefile("r") self.stderr = self.channel.makefile_stderr("r") self.output_thread = Thread(target=self.output) self.error_thread = Thread(target=self.error) self.output_thread.start() self.error_thread.start() self.sftp_client = self.client.open_sftp() return self def __getattr__(self, attr): if attr not in self.attrs: raise AttributeError( f"'{self.__class__}' object has no attribute '{attr}'") elif hasattr(self.sftp_client, attr): return getattr(self.sftp_client, attr) elif hasattr(self.client, attr): return getattr(self.client, attr) def __exit__(self, et, ev, tb): self.sftp_client.close() self.stdout.close() self.stderr.close() self.stdin.close() self.channel.close() self.client.close() def exec(self, command): self.stdin.write(command + "\n") def output(self): for line in self.stdout: self.queue.put(self.hostname, "stdout", line) def error(self): for line in self.stderr: self.queue.put(self.hostname, "stderr", line)
def searchTopology(devices): for device in devices: connection = SSHClient() connection.set_missing_host_key_policy(paramiko.AutoAddPolicy()) connection.connect(device, username=username, password=password, look_for_keys=False, allow_agent=False) new_connection = connection.invoke_shell() output = clear_buffer(new_connection) time.sleep(2) new_connection.send("terminal length 0\n") output = clear_buffer(new_connection) try: router = output.decode('utf-8') except: print('The router interface is down') new_connection.close() continue router = router[2:4] # If the router is already in the list of routers, close the ssh connection if router in routers: print(f'The router {router} is already visited') new_connection.close() continue # Retrieving the routing table new_connection.send(route_table) time.sleep(2) table = new_connection.recv(max_buffer).decode('utf-8') routes, routers[router] = getNetworksDirectlyConnected(table) # Filtering the obtained list dispositivos = [ route.replace('252', '253') for route in routes if route.endswith('.252') ] for dispositivo in dispositivos: print( f'Obtaining the devices that are directly connected to this router: {dispositivo}' ) new_connection.send(f'ssh -l {username} {dispositivo} \n') time.sleep(2) new_connection.send(f'{password}\n') time.sleep(2) new_connection.send(route_table) time.sleep(2) # Obtaining the routing table for every single router table = new_connection.recv(max_buffer).decode('utf-8') router = table[-3] + table[-2] _, routers[router] = getNetworksDirectlyConnected(table) new_connection.send('exit\n') time.sleep(2) # Closing the ssh connection new_connection.close()
def describeInterface(hostname): if hostname == 'R4': print("Setting up the routing table for Router 4...") connection = SSHClient() connection.set_missing_host_key_policy(paramiko.AutoAddPolicy()) connection.connect(gateway, username=username, password=password, look_for_keys=False, allow_agent=False) new_connection = connection.invoke_shell() time.sleep(2) new_connection.send('terminal length 0\n') print(f'Obtaining the {hostname} router information\n') router_info = getNetworsRouter(hostname, routers) print(router_info) # Executing the commands for setting up the routing table new_connection.send('conf t\n') time.sleep(2) new_connection.send('router ospf 1\n') time.sleep(2) id_network_R3 = router_info['R3'][1] new_connection.send(f'network { id_network_R3 } 0.0.0.255 area 0\n') time.sleep(2) new_connection.send('redistribute rip metric 200 subnets\n') time.sleep(2) new_connection.send('redistribute static metric 200 subnets\n') time.sleep(2) new_connection.send('exit\n') time.sleep(2) new_connection.send('router rip\n') time.sleep(2) new_connection.send('version 2\n') time.sleep(2) new_connection.send('redistribute static\n') time.sleep(2) new_connection.send('redistribute ospf 1\n') time.sleep(2) new_connection.send('no auto-summary\n') time.sleep(2) id_network_R2 = router_info['R2'][1] new_connection.send(f'network {id_network_R2}\n') time.sleep(2) new_connection.send('exit\n') time.sleep(2) network_R1 = router_info['R1'] new_connection.send( f'ip route 10.0.5.0 255.255.255.0 {network_R1[0]}\n') time.sleep(2) # Closing the ssh connection new_connection.close() return jsonify(Router=hostname, Devices_Directly_Connected=routers[hostname])
def oxe_netdata_update(host, data, port=22, password='******', root_password='******'): """Summary Args: host (TYPE): Description data (TYPE): Description port (int, optional): Description password (str, optional): Description root_password (str, optional): Description """ client = SSHClient() # use the paramiko SSHClient client.set_missing_host_key_policy( AutoAddPolicy()) # automatically add SSH key try: client.connect(host, port, username='******', password=password) except AuthenticationException: print('*** Failed to connect to {}:{}'.format(host, port)) channel = client.invoke_shell() while channel.recv_ready() is False: sleep(3) # OXE is really slow on mtcl connexion stdout = channel.recv(4096) channel.send('su -\n') while channel.recv_ready() is False: sleep(0.5) stdout += channel.recv(1024) channel.send(root_password + '\n') while channel.recv_ready() is False: sleep(0.5) stdout += channel.recv(1024) channel.send('cat >> /usr/netadm/data/netdata << EOF\n' + data + '\nEOF\n') while channel.recv_ready() is False: sleep(0.5) stdout += channel.recv(1024) channel.send('netadmin -c\n') while channel.recv_ready() is False: sleep(2) stdout += channel.recv(1024) channel.send('chmod 664 /usr/netadm/data/netdata\n') while channel.recv_ready() is False: sleep(0.5) stdout += channel.recv(1024) # print(stdout.decode(encoding='UTF-8')) channel.close() client.close()
def oxe_wbm_update_requests_quota(host, port, password, root_password, new_limit=50): """Update WBM requests limit for configuration zone (not authentication zone) Args: host (STR): OmniPCX Enterprise IP address port (INT): SSH port password (STR): mtcl password root_password (TYPE): root password new_limit (int, optional): Description """ # Build OXE sed command cmd = 'sed -i -e \'s/zone=two\:1m rate\=2r\/s/zone=two\:1m rate\=' + new_limit + \ 'r\/s/g\' /usr/local/openresty/nginx/conf/wbm.conf\n' # SSH connection client = SSHClient() # use the paramiko SSHClient client.set_missing_host_key_policy( AutoAddPolicy()) # automatically add SSH key try: client.connect(host, port, username='******', password=password) except AuthenticationException: print('*** Failed to connect to {}:{}'.format(host, port)) channel = client.invoke_shell() while channel.recv_ready() is False: sleep( 3 ) # OXE is really slow on mtcl connexion (Update this timer on physical servers) stdout = channel.recv(4096) channel.send('su -\n') while channel.recv_ready() is False: sleep(1) stdout += channel.recv(1024) channel.send(root_password + '\n') while channel.recv_ready() is False: sleep(0.5) stdout += channel.recv(1024) # channel.send('sed -i -e \'s/zone=two\:1m rate\=2r\/s/zone=two\:1m rate\=50r\/s/g\' /usr/local/openresty/nginx/conf/wbm.conf\n') channel.send(cmd) while channel.recv_ready() is False: sleep(0.5) stdout += channel.recv(1024) channel.close() client.close()
def _fetch_probsup_dump(self, ap): client = SSHClient() client.set_missing_host_key_policy(AutoAddPolicy()) try: client.connect(hostname=ap["ip_address"], port=ap["ssh_port"], username=ap["login"], password=ap["password"], timeout=3) except (NoValidConnectionsError, timeout): return "" connect = client.invoke_shell() connect.send("wl -i %s probsup_dump\n" % ap["monitoring_interface"]) while not connect.recv_ready(): sleep(0.1) probsup_dump = connect.recv(50000).decode() connect.close() client.close() return probsup_dump
def run(self, hostname, username, password): if self.commands.__len__() == 0: return False method = Device.objects.filter(host=hostname)[0].loginmethod if method == "ssh": ssh = SSHClient() ssh.set_missing_host_key_policy(AutoAddPolicy()) try: ssh.connect(hostname=hostname, username=username, password=password, timeout=2) except: return False shell = ssh.invoke_shell() shell.send('config terminal' + '\r\n') for command in self.commands: shell.send(command + '\r\n') sleep(0.5) return True elif method == "telnet": pass
def Hostname_Updater(ipaddr, username='******', password='******'): remote_conn_pre = SSHClient() remote_conn_pre.set_missing_host_key_policy(AutoAddPolicy()) remote_conn_pre.connect(ipaddr, username=username, password=password, look_for_keys=False, allow_agent=False) print "...Connection established on {}...".format(ipaddr) remote_conn = remote_conn_pre.invoke_shell() output = remote_conn.recv(1000) print output remote_conn.send("terminal length 0\renable\rcisco\rconf t\r") hostname = raw_input("New hostname: ") time.sleep(0.5) remote_conn.send("hostname {}\r".format(hostname)) print "Hostname successfully updated to {}".format(hostname) remote_conn_pre.close()
def SSH_Connect(): remote_conn_pre = SSHClient() remote_conn_pre.set_missing_host_key_policy(AutoAddPolicy()) remote_conn_pre.connect(ipaddr, username=username, password=password, look_for_keys=False, allow_agent=False) remote_conn = remote_conn_pre.invoke_shell() print "Interactive SSH session established" output = remote_conn.recv(1000) print output remote_conn.send('terminal length 0\renable\rconf t') hostname = raw_input("Would would you like to change the hostname to: ") remote_conn.send("hostname {}\r".format(hostname)) time.sleep(2) print "Hostname successfully changed {}".format(hostname) remote_conn_pre.close()
def startConnection(self): """ connection to remote server can launch a thread checking every minute your mailbox... """ #if not self.directory:return #self.parent().close() self.close() client = SSHClient() client.set_missing_host_key_policy(AutoAddPolicy()) try: client.connect(str(self.host.text()), username=str(self.username.text()), password=str(self.password.text())) except SSHException: qApp.instance().showErrorMessage( "Error", "The ssh session could not be established") except AuthenticationException: qApp.instance().showErrorMessage("Error", "Authentication failed") except BadHostKeyException: qApp.instance().showErrorMessage( "Error", "the server's host key could not be verified") sftpCp = self.cleaningRepository(client) if sftpCp: sftp = client.open_sftp() self.sftpCopying(sftp) sftp.close() else: self.retrieveDirTree(c, out) self.makeRScript(client) self.makeShellScript(client) if self.interactiveSession.isChecked(): import interactive print('invoking a shell') chan = client.invoke_shell() chan.send('bash\n') interactive.interactive_shell(chan) chan.close() else: self.launchCommand(client) client.close()
async def accept(websocket, path): dataline = "" # ssh client = SSHClient() client.set_missing_host_key_policy(AutoAddPolicy()) client.connect(hostname='ip address', username='******', password='******', port=22) channel = client.invoke_shell() while not channel.recv_ready(): time.sleep(0.1) buff = '' resp = channel.recv(9999).decode('utf-8') buff += resp print(resp) # login message dataline = resp def send_command(cmd): buff = '' while not buff.endswith(']# '): channel.send(cmd + '\n') resp = channel.recv(9999).decode('utf-8') buff += resp return str(resp) while True: # クライアントからメッセージ待機 data = await websocket.recv() if data == "send": # クライアントに送信 dataline = send_command(dataline) await websocket.send(dataline) data = "" dataline = "" dataline = dataline + data print("received: " + data) print("dataline: " + dataline)
class SSHServerControl(AgentControl): """ Inherit from AgentControl. Implement all existing methods in the way of SSH. """ def __init__(self): super(SSHServerControl, self).__init__() self.ssh = SSHClient() self.ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) self.shell = None def login(self, identity): try: self.ssh.connect(identity.ip, username=identity.dev_id, password=identity.dev_pw) self.shell = self.ssh.invoke_shell() buf = '' while not (buf.endswith('$ ') or buf.endswith('# ')): buf += self.shell.recv(9999) print buf except BadHostKeyException, e: print '%s' % e except AuthenticationException, e: print '%s' % e
class ParamikoWrapper: def __init__(self, hostname, username, password): self.client = SSHClient() self.client.load_system_host_keys() # Research more meaningful exceptions to catch try: self.client.connect(hostname=hostname, username=username, password=password) self.client.connected = True except: self.client.connected = False return try: self.session = self.client.invoke_shell() self.session.setblocking(0) self.session.settimeout(.25) except: self.client.connected = False pass def send_input(self, input): self.session.send(input) def flush_output(self): out = '' while True: try: concat = self.session.recv(10000) out += concat except: return out def is_connected(self): return self.client.connected def __del__(self): self.client.close()
def get_router(): response = {} for router in request.json["routers"]: try: ssh = SSHClient() ssh.set_missing_host_key_policy(AutoAddPolicy()) ssh.connect(router["ip"], router["port"], router["user"], router["password"]) except Exception: response[router["ip"] + "_" + router["interface"]] = "Connection error" ssh.close() else: ssh_command = ssh.invoke_shell() ssh_command.send("show interface {}\n".format(router["interface"])) time.sleep(2) output = ssh_command.recv(5000).decode() # Validate if interface exist if output.find("Invalid input detected at") < 0: extract_data = {} if "bandwidth" in request.json["info"]: search = re.search(r'BW (.*?), ', output) if search: extract_data["bandwidth"] = search.group(1) else: extract_data["bandwidth"] = "bandwidth not found" if "address" in request.json["info"]: search = re.search(r'Internet address is (.*?)\r\n', output) if search: extract_data["address"] = search.group(1) else: extract_data["address"] = "address not found" response[router["ip"] + "_" + router["interface"]] = extract_data else: key = router["ip"] + "_" + router["interface"] response[key] = "Interface not found" ssh.close() return response
def oxe_purge_rainbowagent_logs(host, port=22, password='******', root_password='******'): """Summary Args: host (TYPE): Description port (int, optional): Description password (str, optional): Description root_password (str, optional): Description """ client = SSHClient() # use the paramiko SSHClient client.set_missing_host_key_policy( AutoAddPolicy()) # automatically add SSH key try: client.connect(host, port, username='******', password=password) except AuthenticationException: print('*** Failed to connect to {}:{}'.format(host, port)) channel = client.invoke_shell() while channel.recv_ready() is False: sleep(3) # OXE is really slow on mtcl connexion stdout = channel.recv(4096) channel.send('su -\n') while channel.recv_ready() is False: sleep(0.5) stdout += channel.recv(1024) channel.send(root_password + '\n') while channel.recv_ready() is False: sleep(0.5) stdout += channel.recv(1024) channel.send('rm -f /var/log/rainbowagent.log.*\n') while channel.recv_ready() is False: sleep(0.5) stdout += channel.recv(1024) # print(stdout.decode(encoding='UTF-8')) channel.close() client.close()
def registerSSHUser(username, password, router_address, flag=''): default_user = '******' default_pass = '******' commands = [ 'enable\n', 'config t\n', f'{flag} username {username} privilege 15 password {password}\n', 'end\n' ] connection = SSHClient() connection.set_missing_host_key_policy(paramiko.AutoAddPolicy()) connection.connect(router_address, username=default_user, password=default_pass, look_for_keys=False, allow_agent=False) new_connection = connection.invoke_shell() output = clear_buffer(new_connection) time.sleep(wait) for command in commands: new_connection.send(command) time.sleep(wait) # Closing the ssh connection new_connection.close()
if host_keys.has_key(host_): hostkeytype = host_keys[host_].keys()[0] hostkey = host_keys[host_][hostkeytype] print 'Using host key of type %s' % hostkeytype ssh_client = SSHClient() ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) ssh_client.connect(hostname=host_, username=user_, password=pass_) #privatekeyfile = os.path.expanduser('~/.ssh/id_rsa') #mykey = paramiko.RSAKey.from_private_key_file(privatekeyfile) t = paramiko.Transport((host_,port_)) t.connect(username=user_,password=pass_,hostkey=hostkey) sftp = paramiko.SFTPClient.from_transport(t) connection = ssh_client.invoke_shell() stdin = connection.makefile('wb') stdout = connection.makefile('rb') dirlist = sftp.listdir('.') print "DirList:", dirlist filepaths = ['c/fileio.c', 'c/fileio.h', 'c/min.c', 'c/max.c', 'c/rand.c'] sftp.mkdir("c") for i in filepaths: sftp.put(i,i) stdin.write( ''' cd gcc -o ran c/fileio.h c/fileio.c c/rand.c
class Manager: """ The class that holds the methods used to configure the devices. """ CONFIG_FILE_PATH = os.path.join(os.path.dirname(__file__), 'data', 'config.json') variables = { "DEVICE_HOSTNAME": None, "ENABLE_PASSWORD": None, "DOMAIN_NAME": None, "VLAN_NUMBER": None } keys = list(variables.keys( )) # keywords that will be replaced if found on 'config.json' commands. configuration_keywords = ('DEFAULT_CONFIG', 'SET_HOSTNAME', "CREATE_VLAN", 'DELETE_VLAN', 'ACCESS_SSH_ONLY', 'ACCESS_TELNET_ONLY', 'ACCESS_SSH_TELNET', 'SHOW_INTERFACES_STATUS', 'SHOW_INTERFACES_IP') config_file = open(CONFIG_FILE_PATH, "r") config_json = json.load(config_file) def __init__(self): self.__devices = [] self.__vlans_to_configure = None self.__obj_connect = None self.__shell = None def add_device(self, device): """ Add the device (obj) to the list of devices to be configured. Args: device (:obj: `Device`): The device to be added. """ self.__devices.append(device) def configure_devices(self, *args): """ Starts the configuration of devices on the devices list. """ for _, device in enumerate(self.__devices): self.variables['ENABLE_PASSWORD'] = device.enable_secret self.variables['DOMAIN_NAME'] = device.domain_name auxiliar_functions.clear() print(f"\n[ + ] CONFIGURING THE {_+1}º DEVICE...\n") if len(args) < 1: print( f"\n\n[ ! ] You must choose at least one configuration (see README or documentation)." ) auxiliar_functions.close() if device.connection_protocol == "TELNET": try: self.__login_over_telnet(device) self.__configure(device, args) self.__obj_connnect.close() except Exception as e: print(f"\n\n{e}") auxiliar_functions.close() else: try: self.__login_over_ssh(device) self.__configure(device, args) self.__obj_connect.close() except Exception as e: print(f"\n\n{e}") auxiliar_functions.close() auxiliar_functions.close() @property def vlans_to_configure(self): return self.__vlans_to_configure @vlans_to_configure.setter def vlans_to_configure(self, vlans): self.__vlans_to_configure = vlans def __login_over_telnet(self, device): """ Creates an Telnet client object, then tries to login to the device using its attributes. Args: device (:obj: `Device`): The device that the manager will connect to. """ try: self.__obj_connect = Telnet(device.ip_address, "23", 5) # self.obj_connect.set_debuglevel(1) # uncomment this line to enable debug for Telnet obj. except Exception as error: print(f"[ ! ] {error}.") auxiliar_functions.close() else: if device.vty_username != "": self.__obj_connect.read_until(b"Username:"******"\n") sleep(0.5) self.__obj_connect.read_until(b"Password:"******"\n") sleep(0.5) self.__identify_errors(device) self.__obj_connect.write(b"enable\n") self.__obj_connect.read_until(b"Password:"******"\n") sleep(0.5) self.__identify_errors(device) def __login_over_ssh(self, device): """ Creates an SSHClient object, load the keys, then tries to login to the device using its attributes. Args: device (:obj: `Device`): The device that the manager will connect to. """ self.__obj_connect = SSHClient() self.__obj_connect.load_system_host_keys() self.__obj_connect.set_missing_host_key_policy(AutoAddPolicy()) try: self.__obj_connect.connect(device.ip_address, 22, device.vty_username, device.vty_password) self.__shell = self.__obj_connect.invoke_shell( ) # Opens a shell to run commands. except Exception as error: print(f"[ ! ] {error}") self.__obj_connect.close() auxiliar_functions.close() else: self.__identify_errors(device) self.__shell.send(b"enable\n") sleep(0.5) self.__shell.send(device.enable_secret.encode() + b"\n") sleep(0.5) self.__identify_errors(device) def __configure(self, device, configurations): """ Start running commands on device if the configurations keys exists on 'config.json' file. Args: device (:obj: `Device`): The device to be configured. configurations (str): The command keys based on 'config.json'. """ for config_key in configurations: if config_key in self.configuration_keywords: if config_key == 'SET_HOSTNAME': variables["DEVICE_HOSTNAME"] = input("[->] Set hostname: ") self.__send_commands(device, config_key) elif config_key == 'CREATE_VLAN' or config_key == 'DELETE_VLAN': if self.__vlans_to_configure == None: print( "\n\n[ ! ] You must specify the VLANs to be configured!(see README or documentation.)" ) auxiliar_functions.close() for vlan in self.__vlans_to_configure: if int(vlan) not in range(3968, 4048) and int(vlan) != 4094: self.variables["VLAN_NUMBER"] = vlan self.__send_commands(device, config_key) self.variables["VLAN_NUMBER"] = self.vlans_to_configure[0] else: self.__send_commands(device, config_key) else: print( f"\n\n[ ! ] There is no valid configuration for '{config_key}'." ) auxiliar_functions.close() def __send_commands(self, device, config_key): """ Run the commands on the device based on the choosen configuration keyword. Args: device (:obj: `Device`): The device that will receive the commands. config_key (int): The configuration key to run based on the 'config.json' file. """ commands = list(self.config_json[config_key].values())[0] if device.connection_protocol == "SSH": for command in commands: found_key = list(filter(lambda key: key in command, self.keys)) if len(found_key) > 0: self.__shell.send( command.replace( found_key[0], self.variables[found_key[0]]).encode('ascii')) self.__identify_errors(device) sleep(0.6) else: self.__shell.send(command.encode()) self.__identify_errors(device) sleep(0.6) else: for command in commands: found_key = list( filter(lambda key: key in command, self.keys)) # found commands to be replaced. if len(found_key) > 0: self.__obj_connect.write( command.replace( found_key[0], self.variables[found_key[0]]).encode('ascii')) self.__identify_errors(device) sleep( 0.6 ) # timeout before send another command to prevent errors. else: self.__obj_connect.write(command.encode('ascii')) self.__identify_errors(device) sleep(0.6) def __identify_errors(self, device): """ Handle the command output to verify if there is errors based on a dict with some errors keywords and its descriptions. Args: device (:obj: `Device`): The current device being configurated. """ def find_error_on_line(output_line): """ Verify if the output command line has errors based on a predefined dict. Args: output_line (str): The device output command line to be verified. """ found_error = list( filter(lambda error: error in output_line, errors_keywords)) if len(found_error) > 0: print(f"[ ! ] {errors_dict[found_error[0]]}") auxiliar_functions.close() else: print(output_line, end='') errors_dict = { '% Login invalid': "\n\n[ ! ] Invalid VTY login credentials!", '% Bad passwords': "\n\n[ ! ] Invalid VTY password!", '% Bad secrets': "\n\n[ ! ] Invalid secret! Can't configure", '% No password set': "\n\n[ ! ] No enable password configured on device! Cant run scripts.", 'Translating': "\n\n[ ! ] Username not configured on device. Set a username or leave it blank.", 'number which is out of the range 1..4094': "\n\n[ ! ] Invalid vlan number!" } errors_keywords = [key for key in errors_dict] if device.connection_protocol == 'TELNET': errors_keywords = [key for key in errors_dict] line = self.__obj_connect.read_very_eager().decode('ascii') if '% Do you really want to replace them?' in line or '% You already have RSA keys defined' in line: self.__obj_connect.write(b'no\n') find_error_on_line(line) else: line = self.__shell.recv(65535).decode('ascii') if '% Do you really want to replace them?' in line or '% You already have RSA keys defined' in line: self.__shell.send(b'no\n') find_error_on_line(line)
class SshConnector: host = "" user = "" ssh_config = None ssh_client = None batch_sys = None batch_config = None ssh_log = "" prompt = "" def __init__(self, host, home_path, batch_sys, user=None): self.batch_sys = Batchsystem() self.batch_sys.read_config() self.batch_config = self.batch_sys.get_batchsystem_config(batch_sys) if user is None: self.host = host self.read_ssh_config(host) self.connect_with_config() else: self.host = host self.user = user self.connect(host, user) self.detect_prompt(home_path) # connect to host with config def connect_with_config(self): self.ssh_client = SSHClient() self.ssh_client.load_system_host_keys() self.ssh_client.set_missing_host_key_policy(AutoAddPolicy()) self.ssh_client.connect(self.ssh_config['hostname'], username=self.ssh_config['user']) # connect with user parameter def connect(self, host, user): password = getpass.getpass() self.ssh_client = SSHClient() self.ssh_client.set_missing_host_key_policy(AutoAddPolicy()) self.ssh_client.connect(host, username=user, password=password) # read ssh config of user def read_ssh_config(self, hostname): config_file = os.path.join(os.getenv('HOME'), '.ssh/config') config = SSHConfig() config.parse(open(config_file, 'r')) self.ssh_config = config.lookup(hostname) if len(self.ssh_config.keys()) < 2: print("Hostname no found in .ssh/config") #returns an session channel def create_session(self): return self.ssh_client.invoke_shell() # execute command on the host, blocking semantic def execute(self, cmd): ssh_stdin, ssh_stdout, ssh_stderr = self.ssh_client.exec_command(cmd) self.ssh_log += str(ssh_stderr.read()) return str(ssh_stdout.read()) # TODO implement own function to check prompt in reverse order def execute_in_session(self, cmd, channel): while not channel.send_ready(): time.sleep(0.00001) channel.send(cmd + '\n') recv_buffer = " " while not recv_buffer.endswith(self.prompt + ' '): rsp = channel.recv(1024) recv_buffer += rsp pattern = self.prompt + ' ' + cmd begin = recv_buffer.find(pattern) + len(pattern) + 2 end = len(recv_buffer) - len(self.prompt + ' ') return recv_buffer[begin:end] def detect_prompt(self, home_path): channel = self.ssh_client.invoke_shell() while not channel.send_ready(): time.sleep(0.00001) channel.send('echo $HOME\n') recv_buffer = '' while not home_path in recv_buffer: resp = channel.recv(1024) recv_buffer += resp idx = recv_buffer.rfind('echo') prompt = '' for i in range(idx - 2, -1, -1): if(recv_buffer[i] == ' '): break elif(recv_buffer[i] != '\r' and recv_buffer[i] != '\n' and recv_buffer[i] != '\t'): prompt += recv_buffer[i] self.prompt = prompt[::-1] def print_log(self): print("\n\nSSH LOG") print("========") print(self.ssh_log) def print_modules(self): print(self.exec_command("module av")) def load_modules(self, modules, channel): return self.execute_in_session("module load {}".format(modules), channel) # modules must seperated with whitespaces def submit_interactive_job(self, app, ntasks, nnodes=None, runtime=None, modules=None): channel = self.create_session() if not modules is None: print(self.load_modules(modules, channel)) cmd = self.batch_config['shell_command'] + ' ' cmd += self.batch_config['task_count'] + " {0} ".format(ntasks) if not nnodes is None: cmd += self.batch_config['node_count'] + " {0} ".format(nnodes) if not runtime is None: cmd += runtime + ' ' cmd += app print("Job submitted\nWaiting for ressources...") print(self.execute_in_session(cmd, channel)) def submit_job(self, path_to_exec, modules, runtime, options, sys_name): conf = self.batch_sys.get_batchsystem_config(sys_name) self.load_modules(modules) cmd = "{0} {1} {2} {3}".format(conf['shell_command'], options, runtime, path_to_exec) self.exec_command(cmd)
from paramiko import SSHClient, AutoAddPolicy from emoji import EMOJI_UNICODE as emos from emoji import emojize ssh = SSHClient() ssh.set_missing_host_key_policy(AutoAddPolicy()) ssh.connect( "52.49.91.111", port=22000, username="******", password="******", look_for_keys=False, ) chan = ssh.invoke_shell() for k in emos: print(f"Trying emoji {k} -> {emos[k]} {emojize(k)}\n") try: while not chan.recv_ready(): pass b1 = chan.recv(1024).decode() while not chan.send_ready(): pass chan.send(f"{emojize(k)}\n")
def offshell(name, load_system_host_keys, ssh_config, etcd): host, port = etcd.split(":") node = dict_to_node( loads(etcd3.client(host=host, port=int(port)).get(name)[0])) if node.state != NodeState.RUNNING: raise EnvironmentError( "Node isn't running, it's {}. Ensure it's ON, then try again.". format(node.state)) connection_d = { "hostname": node.public_ips[0], "username": node.extra["user"] if "user" in node.extra else node.extra.get( "ssh_config", {}).get("User"), "password": node.extra.get("password"), "key_filename": node.extra.get("ssh_config", {}).get("IdentityFile"), } if ssh_config: if not connection_d["key_filename"]: root_logger.warn( "Cannot set password in ssh_config format. You'll still be prompted." ) tab = " " * 4 if "ssh_config" in node.extra and len(node.extra["ssh_config"]) > 1: host = node.extra["ssh_config"].pop("Host") print("Host {host}\n{rest}".format( host=host, rest=tab + tab.join( "{} {}\n".format(k, v[0] if isinstance(v, list) else v) for k, v in iteritems(node.extra["ssh_config"]))[:-1], )) else: print("Host {name}\n" "{tab}HostName {hostname}\n" "{tab}User {username}\n" "{last_line}".format( name=name.rpartition("/")[2], hostname=connection_d["hostname"], username=connection_d["username"], tab=tab, last_line="{tab}IdentityFile {key_filename}".format( tab=tab, key_filename=connection_d["key_filename"]) if connection_d["key_filename"] else "", )) known_hosts = path.join(expanduser("~"), ".ssh", "known_hosts") s = "" if exists(known_hosts): with open(known_hosts, "rt") as f: s = f.read() if connection_d["hostname"] not in s: print( "After checking the key fingerprint, add it to your known hosts with:" "\nssh-keyscan {host} >> {known_hosts}".format( host=connection_d["hostname"], known_hosts=known_hosts), file=stderr, ) return client = SSHClient() if load_system_host_keys: client.load_system_host_keys() client.connect(**connection_d) chan = client.invoke_shell() interactive_shell(chan) chan.close() client.close()
class Executor(object): def __init__(self, hostname, username, key, debug=False): self.debug = debug self.client = SSHClient() self.client.set_missing_host_key_policy(MissingHostKeyPolicy()) self.client.connect(hostname, username=username, pkey=key, look_for_keys=False, compress=True) self.chan = self.client.invoke_shell() self.chan.settimeout(0.1) self.prompt_regex = "# $" self.read() self.set_prompt() def set_prompt(self): prompt = "fio8g3rfubsd97g34iu:# " self.chan.send('export PS1="%s" PS2=""\n' % prompt) self.prompt_regex = re.escape(prompt) + '$' self.read() def run(self, cmdline): """Run a command and piece out the console output.""" # run the command cmdline += "; echo\n" self.chan.send(cmdline) # piece out the response response = self.read() m = re.match(re.escape(cmdline) + "(.*)" + self.prompt_regex, response) # always return something if m: return m.group(1) else: return response def recv(self, how_much = 1024): """Reads bytes from the session, catching timouts.""" try: data = self.chan.recv(how_much) logger.debug("recv %d bytes: %s" % (len(data), repr(data))) return data except sock_timeout: return None def read(self): """Reads until the prompt is seen again.""" data = '' buf = self.recv() while not re.search(self.prompt_regex, data): if buf is not None: data += buf buf = self.recv() logger.debug("returning buffer: %s" % data) return data def open_sftp(self): return self.client.open_sftp() def close(self): try: self.chan.close() except: pass try: self.client.close() except: pass
class Ssh(ClientBase, Commands): def __init__(self, options): """ Initialize the SSH Bee, and the Base classes. :param sessions: A dict which is updated every time a new session is created. :param options: A dict containing all options """ ClientBase.__init__(self, options) Commands.__init__(self) self.client = SSHClient() self.client.set_missing_host_key_policy(AutoAddPolicy()) self.comm_chan = None def start(self): """ Launches a new SSH client session on the server taken from the `self.options` dict. :param my_ip: IP of this Client itself """ username = self.options['username'] password = self.options['password'] server_host = self.options['server'] server_port = self.options['port'] honeypot_id = self.options['honeypot_id'] session = self.create_session(server_host, server_port, honeypot_id) self.sessions[session.id] = session logger.debug( 'Sending ssh bait session to {0}:{1}. (bait id: {2})'.format(server_host, server_port, session.id)) try: self.connect_login() session.did_connect = True # TODO: Handle failed login session.add_auth_attempt('plaintext', True, username=username, password=password) session.did_login = True except (SSHException, AuthenticationFailed) as err: logger.debug('Caught exception: {0} ({1})'.format(err, str(type(err)))) else: command_count = 0 command_limit = random.randint(6, 11) while command_count < command_limit: command_count += 1 self.sense() comm, param = self.decide() self.act(comm, param) gevent.sleep(random.uniform(0.4, 5.6)) self.logout() session.did_complete = True finally: session.alldone = True session.end_session() def send_command(self, cmd): """ Send a command to the remote SSH server. :param cmd: The command to send """ logger.debug('Sending {0} command.'.format(cmd)) self.comm_chan.sendall(cmd + '\n') def get_response(self): """ Get the response from the server. *This may not return the full response* :return: Response data """ while not self.comm_chan.recv_ready(): time.sleep(0.5) return self.comm_chan.recv(2048) def connect_login(self): """ Try to login to the Remote SSH Server. :return: Response text on successful login :raise: `AuthenticationFailed` on unsuccessful login """ self.client.connect(self.options['server'], self.options['port'], self.options['username'], self.options['password']) self.comm_chan = self.client.invoke_shell() time.sleep(1) # Let the server take some time to get ready. while not self.comm_chan.recv_ready(): time.sleep(0.5) login_response = self.comm_chan.recv(2048) if not login_response.endswith('$ '): raise AuthenticationFailed return login_response def logout(self): """ Logout from the remote server """ self.send_command('exit') self.get_response() self.comm_chan.close()
def ssh_connect(user, pwd, ip, commands): try: # Initiate session = SSHClient() # Auto accept unknown host keys. session.set_missing_host_key_policy(AutoAddPolicy()) # Connect to the device session.connect(ip, username=user, password=pwd) # Start an interactive shell session on the router connection = session.invoke_shell() # Send commands to the device for command in commands: connection.send(command) time.sleep(2) output = connection.recv(2048) # You might want to modify the conditon. It check the invalid command if b"% Invalid input" in output: print(f"'{command.rstrip()}' is an invalid command. Stopped!") connection.close() sys.exit() connection.close() except AuthenticationException: print("Wrong username and password! Stopping script...") sys.exit()