def trans(): """ Create `LoopSocket`-based server/client `Transport`s, yielding the latter. Uses `NullServer` under the hood. """ # NOTE: based on the setup/teardown/start_server/verify_finished methods # found in ye olde test_auth.py # "Network" setup socks = LoopSocket() sockc = LoopSocket() sockc.link(socks) tc = Transport(sockc) ts = Transport(socks) # Start up the in-memory server host_key = RSAKey.from_private_key_file(_support('test_rsa.key')) ts.add_server_key(host_key) event = threading.Event() server = NullServer() ts.start_server(event, server) # Tests frequently need to call Transport.connect on the client side, etc yield tc # Close things down tc.close() ts.close() socks.close() sockc.close()
def sftp_server(): """ Set up an in-memory SFTP server thread. Yields the client Transport/socket. The resulting client Transport (along with all the server components) will be the same object throughout the test session; the `sftp` fixture then creates new higher level client objects wrapped around the client Transport, as necessary. """ # Sockets & transports socks = LoopSocket() sockc = LoopSocket() sockc.link(socks) tc = Transport(sockc) ts = Transport(socks) # Auth host_key = RSAKey.from_private_key_file(_support('test_rsa.key')) ts.add_server_key(host_key) # Server setup event = threading.Event() server = StubServer() ts.set_subsystem_handler('sftp', SFTPServer, StubSFTPServer) ts.start_server(event, server) # Wait (so client has time to connect? Not sure. Old.) event.wait(1.0) # Make & yield connection. tc.connect(username='******', password='******') yield tc
def run(self, ip, port=22, timeout=2): try: socket.setdefaulttimeout(timeout) s = socket.socket() s.connect((ip, port)) banner = s.recv(50).strip('\r\n').split(' ') try: self.data["version"] = banner[0] self.data["os"] = banner[1] except IndexError: pass s.send('{}\r\n'.format(banner[0])) self._raw_recv = s.recv(2048) s.close() self._parse_raw_data() tran = Transport((ip, port)) tran.start_client() pubkey = tran.get_remote_server_key() self.data["pubkey_name"] = pubkey.get_name() fp = pubkey.get_fingerprint() self.data["pubkey_fingerprint"] = ':'.join(map(lambda x:x.encode('hex'), fp)) except Exception as e: cprint(str(e), 'error') return None finally: tran.close() self.clear() return True
def remote_scp(ftp_type, host_ip, remote_path, local_path, username, password): ssh_port = 22 try: conn = Transport((host_ip, ssh_port)) conn.connect(username=username, password=password) sftp = SFTPClient.from_transport(conn) if ftp_type == 'remoteRead': print('read') if not local_path: filename = os.path.split(remote_path) local_path = os.path.join('/tmp', filename[-1]) print('开始从服务器下载文件......') sftp.get(remote_path, local_path) print(f'文件{filename[-1]}已经下载到本地') if ftp_type == "remoteWrite": print('write') sftp.put(local_path, remote_path) conn.close() return True except IOError as e: print('没有找到目录', e) except Exception as e: print('error!!!', e)
def _connect(self): host_id = self._host_cfg['host_id'] host, port = self._host_cfg[host_id, 'host'] user = self._host_cfg[host_id, 'user'] passwd = self._host_cfg[host_id, 'password'] timeout = self._host_cfg[host_id, 'timeout'] or None known_hosts = self._host_cfg[host_id, 'known_hosts'] key_type = self._host_cfg[host_id, 'key_type'] key_file = self._host_cfg[host_id, 'key_file'] key_pass = self._host_cfg[host_id, 'key_pass'] try: if key_type: key = _KEY_TYPES[key_type](filename=key_file, password=key_pass) _logger.debug('private key: %s', key.get_name()) else: key = None hostname = utils.format_knownhost(host, port) hostkeys = HostKeys(known_hosts) transport = Transport((host, port)) transport.start_client(timeout=timeout) hostkey = transport.get_remote_server_key() if not hostkeys.check(hostname, hostkey): raise SSHException('Incorrect hostkey') if key: transport.auth_publickey(user, key) else: transport.auth_password(user, passwd) client = transport.open_sftp_client() client.get_channel().settimeout(timeout) _logger.debug('client for %s created', hostname) return client except (OSError, SSHException) as ex: raise ConnectError(f'Connection to server "{host}:{port}"' f' failed: {ex.args!s}')
def _on_open_port(args): host, port, socket = args try: ssh_conn = Transport(socket) if key_type is not None: new_preferred_keys = [key_type] new_preferred_keys.extend(ssh_conn._preferred_keys) ssh_conn._preferred_keys = tuple(new_preferred_keys) try: ssh_conn.start_client() key = ssh_conn.get_remote_server_key() key_md5 = md5(str(key)).hexdigest() fingerprint = ':'.join( a + b for a, b in zip(key_md5[::2], key_md5[1::2])) data_cb(host, port, True, (key.get_name(), fingerprint, b64encode(str(key)))) finally: ssh_conn.close() except (socket_error, NoValidConnectionsError): data_cb(host, port, None, None) except Exception as e: data_cb(host, port, False, 'Exception: {}: {}'.format(type(e), str(e))) finally: socket.close()
def createClient(self): """ create an SSH connection Return:: Transport: Transfer object """ t = None count = 0 event = threading.Event() while count < 3: try: sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.connect((self.hostname, self.port)) t = Transport(sock) t.start_client(event) event.wait(10) if not event.is_set(): self.logger.warn("start client timeout") if not t.is_active(): raise Exception("start client error") break except (socket.error, EOFError, paramiko.SSHException) as e: self.logger.warn( e, 'host: %s:%s connection failed' % (self.hostname, self.port)) count += 1 sock.close() time.sleep(3) else: raise Exception("Create connect to %s failed" % self.hostname) return t
def mx(src: str): spl = src.split(':') if len(spl) != 2: raise BaseException('Invalid url') map_id = spl[1] print('Downloading from MX: {}'.format(map_id)) with urlopen('https://tm.mania-exchange.com/tracks/download/{}'.format( map_id)) as res: _, params = cgi.parse_header(res.headers.get('Content-Disposition', '')) filename = params.get('filename', '{}.Map.Gbx'.format(map_id)) data = res.read() t = Transport((settings['host'], settings['port'])) print('Connecting') t.connect(username=settings['user'], pkey=paramiko.rsakey.RSAKey.from_private_key_file( settings['pkey'])) print('Connected') client = sftp.SFTPClient.from_transport(t) print('Uploading file') dst = settings['dest'] with client.open('{}/{}'.format(dst, filename), 'wb') as file: file.write(data) print('Done') client.close() t.close()
def _get_server_keys(hostname): server_keys = [] # key_type_list = ["ssh-ed25519", "ssh-rsa", "ecdsa-sha2-nistp256"] # default key_type used by ssh-keysca # Supported key_type for OS # alinux ssh-rsa,ssh-ed25519,ecdsa-sha2-nistp256 # ubuntu1404 ssh-rsa,ssh-ed25519,ecdsa-sha2-nistp256 # ubuntu1604 ssh-rsa,ssh-ed25519,ecdsa-sha2-nistp256 # centos7 ssh-rsa,ssh-ed25519,ecdsa-sha2-nistp256 # centos6 ssh-rsa key_type_list = ["ssh-rsa"] for key_type in key_type_list: transport = None try: sock = socket.socket() sock.settimeout(5) sock.connect((hostname, 22)) transport = Transport(sock) transport._preferred_keys = [key_type] transport.start_client() server_keys.append(transport.get_remote_server_key()) except Exception: pass finally: if transport: transport.close() if not server_keys: logging.error("Failed retrieving server key from host '%s'", hostname) return hostname, [(server_key.get_base64(), server_key.get_name()) for server_key in server_keys]
def __init__(self, servaddr, username="", password="", key=None): self.transport_ = Transport(servaddr) self.key_ = key self.user_ = username self.pwd_ = password self.session_ = None
def __init__(self, agent, user): self.hostname = agent.getIp() self.username = user.getLogin() self.publicKey = agent.getPublicKey() self.publicKeyType = agent.getPublicKeyType() self.version = agent.getVersion() self.privateKeyFile = user.getPrivateKeyFile() self.privateKeyType = user.getPrivateKeyType() self.password = user.getPassword() self.raw_data = '' # Create a socket (IPv4 or IPv6): if self.version == 4: sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) elif self.version == 6: sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM) #sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) # Connect to the agent (The SSH tunnel is done later) sock.connect((self.hostname, C.NETCONF_SSH_PORT)) # Create a new SSH session over an existing socket (here sock). self.ssh = Transport(sock) self.i = 1
def upload_file(host, port, usr, psw, local_path, remote_path): file_count = 0 print('-' * 50 + '\n') print('Start uploading files') transport = Transport((host, port)) transport.connect(username=usr, password=psw) sftp = SFTPClient.from_transport(transport) for file_name in listdir(local_path): local_file = local_path + '\\' + file_name remote_file = remote_path + '/' + file_name if file_name.split('.')[-1] == 'css': new_css = cssmini(open(local_file, 'r').read()) with open('tmp.css', 'w') as tmp_css: tmp_css.write(new_css) tmp_css.close() sftp.put(cur_path + tmp_css.name, remote_file) remove(cur_path + tmp_css.name) elif file_name.split('.')[-1] == 'js': new_js = jsmini(open(local_file, 'r', encoding='utf-8').read()) with open('tmp.js', 'w', encoding='utf-8') as tmp_js: tmp_js.write(new_js) tmp_js.close() sftp.put(cur_path + tmp_js.name, remote_file) remove(cur_path + tmp_js.name) else: sftp.put(local_file, remote_file) print(file_name + 'Upload completed') file_count += 1 transport.close() print('All files have been uploaded, Connection has been closed, Number of files:{}'.format(file_count)) print('-' * 50 + '\n')
def connect(self): """ Get a handle to a remote connection """ # Check URL schema = urlparse(self.url) if schema.scheme == 'sftp': self.transport = Transport((schema.hostname, int(schema.port))) else: raise SFTPError('Not a valid sftp url %s, type is %s' % (self.url, schema.scheme)) # Add authentication to transport try: if self.password: self.transport.connect(username=self.user_name, password=self.password) elif self.private_key: self.transport.connect(username=self.user_name, pkey=RSAKey.from_private_key( StringIO(self.private_key))) else: raise SFTPError("No password or private_key defined") # Connect self.conn = SFTPClient.from_transport(self.transport) except (socket.gaierror, error), msg: raise SFTPError( str(msg) + ' while establishing connection to %s' % (self.url, ))
def sftpclient(sftpserver): transport = Transport((sftpserver.host, sftpserver.port)) transport.connect(username="******", password="******") sftpclient = SFTPClient.from_transport(transport) yield sftpclient sftpclient.close() transport.close()
def run(self, ip, port=22, timeout=2): try: socket.setdefaulttimeout(timeout) s = socket.socket() s.connect((ip, port)) banner = s.recv(50).strip(b"\r\n").split(b" ") try: self.data["version"] = banner[0].decode() self.data["os"] = banner[1].decode() except IndexError: pass s.send(banner[0] + b"\r\n") self._raw_recv = s.recv(2048) s.close() self._parse_raw_data() tran = Transport((ip, port)) tran.start_client() pubkey = tran.get_remote_server_key() self.data["pubkey_name"] = pubkey.get_name() fp = pubkey.get_fingerprint() self.data["pubkey_fingerprint"] = fp.hex() except Exception as e: print(repr(e)) return None finally: tran.close() return True
def upload_dir(self, remote_path): transport = Transport((self.sonar_host, self.ssh_port)) transport.connect(username=self.username, password=self.password) with SCPClient(transport) as scp: scp.put(self.local_project_path, recursive=True, remote_path=remote_path) scp.put(os.path.join(self.local_project_path, self.sonar_properties), remote_path=os.path.join( remote_path, self.local_project_path.split(os.sep)[-1])) # execute command ssh = SSHClient() ssh.set_missing_host_key_policy(AutoAddPolicy()) ssh.connect(self.sonar_host, username=self.username, password=self.password) sh_stdin, ssh_stdout, ssh_stderr = ssh.exec_command( 'cd {0} && {1}'.format( remote_path + '/' + self.local_project_path.split(os.sep)[-1], self.sonar_scanner_command)) ssh_stdout = ssh_stdout.read().decode('utf-8') if re.search(self.success_regex, ssh_stdout): print('Link to dashboard: http://{0}:{1}/dashboard?id={2}'.format( self.sonar_host, self.sonar_ui_port, self.project_key)) else: print('Failed to generate Sonar Qube report. Error:\n{0}'.format( ssh_stdout))
def ParamikoMethod(self): trans = Transport((self.ip, 22)) trans.connect(username=self.username, password=self.password) paramiko_client = SSHClient() paramiko_client.set_missing_host_key_policy(AutoAddPolicy()) paramiko_client._transport = trans return paramiko_client
def _get_hostkey(args): host = args['HOST'] file = args['FILE'] hash_ = args['--hash'] try: port = strings.str2port(args['--port']) with Transport((host, port)) as transport: transport.start_client() hostkey = transport.get_remote_server_key() name = hostkey.get_name().split('-', 1)[1].upper() # same fingerprints as the OpenSSH commands generate print(f'{name} ({hostkey.get_bits()}) Fingerprints:') fp_md5 = hashlib.md5() fp_md5.update(hostkey.asbytes()) fp_md5_dig = strings.insert_separator(fp_md5.hexdigest(), ':', 2) print(f' MD5: {fp_md5_dig}') fp_sha = hashlib.sha256() fp_sha.update(hostkey.asbytes()) fp_sha_dig = base64.b64encode(fp_sha.digest()).decode().strip('=') print(f' SHA256: {fp_sha_dig}') while True: a = input(f'Save this key to file "{file}" (yes/no)? ').lower() if a in ('yes', 'no'): break print('Type "yes" or "no"!') if a != 'no': hostname = utils.format_knownhost(host, port) hostkeys = HostKeys() addkey = True if os.path.exists(file): hostkeys.load(file) if hostkeys.lookup(hostname): if hostkeys.check(hostname, hostkey): print(f'Key for "{hostname}" exists' f' in file "{file}"') addkey = False else: del hostkeys[hostname] print(f'Key for "{hostname}" replaced' f' in file "{file}"') else: print(f'Key for "{hostname}" added in file "{file}"') else: print(f'Key for "{hostname}" added in new file "{file}"') if addkey: if hash_: hostname = HostKeys.hash_host(hostname) hostkeys.add(hostname, hostkey.get_name(), hostkey) hostkeys.save(file) except ConfigError as ex: print(ex, file=sys.stderr) return ConfigError.code except (OSError, SSHException) as ex: print(ex, file=sys.stderr) return ConnectError.code except Exception as ex: print(repr(ex), file=sys.stderr) return ExitCodes.FAILURE.code return ExitCodes.SUCCESS.code
def scp(self, src_file, dest_path): transport = Transport((self.host, int(self.port))) transport.connect(username=self.user, password=self.passwd) sftp = SFTPClient.from_transport(transport) try: sftp.put(src_file, dest_path) except IOError as e: raise e
def __init__(self, host, mode): self.__mode = mode self.__username, self.__address = list( map(lambda x: x if ':' not in x else (x.split(':')[0], int(x.split(':')[1])), host.split('@'))) self.__password = None self.__session = None self.__transport = Transport(create_connection(self.__address))
def __init__(self, host, username, password): try: logging.basicConfig(format='%(levelname)s - %(message)s', level=logging.INFO) transport = Transport(sock=(host)) transport.connect(username=username, password=password) self.connection = SFTPClient.from_transport(transport) except: logging.error('Can not able to conenct to server')
def wrapped(*args, **kwargs): original_timeout = getdefaulttimeout() setdefaulttimeout(3) try: Transport((env.host, int(env.port))) return fn(*args, **kwargs) except: print "The following host appears to be offline: " + env.host setdefaulttimeout(original_timeout)
def __init__(self, user, passwd, ip): self.ip = ip try: t = Transport((ip, 22)) t.connect(username=user, password=passwd) self.sftpObject = SFTPClient.from_transport(t) self.status = 'Success' except: self.status = 'Failed'
def connect(self, hostname_address): """connect to SSH target using paramiko Transport/Channel""" self._transport = Transport(hostname_address) self._transport.connect(username=self.user, password=self.passwd) self.ssh_channel = self._transport.open_channel("session") self.pty = self.ssh_channel.get_pty() self.ssh_channel.invoke_shell() self.wait_for_prompt() self.ssh_channel.send("set cli screen-length 0")
def setup(self): self.transport = Transport(self.request) self.transport.load_server_moduli() so = self.transport.get_security_options() so.digests = ('hmac-sha1', ) so.compression = ('*****@*****.**', 'none') self.transport.add_server_key(self.server.host_key) self.transport.set_subsystem_handler('sftp', MyTSFTPServer, MyTSFTPServerInterface)
def __init__(self, sftp_settings): self.transport = Transport( (sftp_settings['HOST'], int(sftp_settings['PORT']))) self.transport.connect(username=sftp_settings['USER'], password=sftp_settings['PASSWORD']) self.connection = SFTPClient.from_transport(self.transport) logger.debug( "SFTPUploader initiated. Sending files to {host}:{port}".format( host=sftp_settings['HOST'], port=sftp_settings['PORT']))
def __init__(self, sock, addr): self.socket = sock self.address = addr self.closed = False self.tags = str(time()) try: self.transport = Transport(sock) except Exception: pass self.chan = None
def sftp_authentication(self): try: transport = Transport((ip_server, 222)) privatekeyfile = os.path.expanduser('./priv_key') mykey = RSAKey.from_private_key_file(privatekeyfile) transport.connect(username='******', pkey=mykey) sftp_client = SFTPClient.from_transport(transport) return sftp_client, transport except Exception, e: print "SFTP Authentication Fail:" + str(e)
def transport(self): transport = Transport((self.host, self.port)) transport.connect(username=self.username, password=self.password) sftp = SFTPClient.from_transport(transport) sftp.put(f'{self.project_url}/web/caweb/html.zip', f'{self.nginx_url}/html.zip') sftp.put(f'{self.project_url}/server/caserver.zip', f'{self.nginx_url}/server/new_caserver.zip') print("transport finished!") transport.close()
def scp_remote_to_local(remote_file_path, local_file_path, ip, username, password): """Copies a file from remote to local""" if not username: username = DEFAULT_CVM_USERNAME if not password: password = DEFAULT_CVM_PASSWD transport = Transport((ip, 22)) transport.connect(username=username, password=password) sftp = SFTPClient.from_transport(transport) sftp.get(remote_file_path, local_file_path)