class Host: def __init__(self, name): self.name = name self.ip = None self.ssh_pkey = None self._ssh = None def __str__(self): return self.name def transport(self): """Returns the ssh transport for this host.""" if self._ssh == None: self._ssh = SSHClient() # import keys using paramikos method self._ssh.load_system_host_keys() # import openssh system host keys host_keys_file = '/etc/ssh/ssh_known_hosts' if os.path.exists(host_keys_file): self._ssh.load_system_host_keys(host_keys_file) # import saved host keys from/for multiapt host_keys_file = os.getenv('HOME','/')+'/.ssh/known_hosts_multiapt' if os.path.exists(host_keys_file): self._ssh.load_host_keys(host_keys_file) # now set our own filename for key save purposes self._ssh._host_keys_filename = host_keys_file # enable our own policy for host key problems self._ssh.set_missing_host_key_policy(SSHAskHostKeyPolicy()) if Main.debug: print 'D: ssh.connect()' self._ssh.connect(self.ip, username=config.remote_username, pkey=self.ssh_pkey) return self._ssh
def __connect(self): assert self._server_pub_key and self._server_url and isinstance(self._my_host_key_policy, MissingHostKeyPolicy) client = SSHClient() client.set_missing_host_key_policy(self._my_host_key_policy) client.connect(self._server_url) # host alias from .ssh/config # self._ssh_client = client return True
def connect_ssh(dns_name, identity_file): ''' ''' client = SSHClient() client.set_missing_host_key_policy(AutoAddPolicy()) client.connect(dns_name, username='******', key_filename=identity_file) return client
def verify(self): client = SSHClient() client.set_missing_host_key_policy(self) client.connect( self.host, username=self.username, password=self.password, )
def ssh_client(*args, **kwargs): client = SSHClient() try: client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) client.connect(*args, **kwargs) except Exception, e: logger.warn("Could not connect to remote host.") logger.exception(e) raise e
class Context(object): def __init__(self, hostname, username, password, xml=False): self.hostname = hostname self.username = username self.password = password self.xml = xml self.ssh_client = SSHClient() self.ssh_client.set_missing_host_key_policy(AutoAddPolicy()) self.ssh_client.connect(self.hostname, username=self.username, password=self.password)
def __create_ssh_client(self): sshclient = SSHClient() sshclient.set_missing_host_key_policy(paramiko.AutoAddPolicy()) for i in range(1, MAX_WAIT_FOR_LOOPS): try: sshclient.connect(hostname=self.hostname, port=22, username=self.login_user, password=self.login_password, timeout=SLEEP_TIMEOUT) return sshclient except socket.error: # no route to host is expected here at first time.sleep(SLEEP_TIMEOUT)
def createClient(host, username=None, pkeyPath=None): """ Creates an SSH client object that can be used to perform SSH-related operations """ client = SSHClient() client.set_missing_host_key_policy(AutoAddPolicy()) pkey = RSAKey.from_private_key_file(os.path.expanduser(pkeyPath)) if pkeyPath else None client.connect(host, username=username, pkey=pkey) return client
def newSshClient(hostname, username="******", localPrivKey=None, timeout=None): from paramiko.client import SSHClient, AutoAddPolicy localPrivKey = localPrivKey or loadRsaPrivKey() missingHostKeyPolicy = AutoAddPolicy() ssh = SSHClient() ssh.set_missing_host_key_policy(missingHostKeyPolicy) ssh.connect(hostname, username=username, pkey=localPrivKey, timeout=timeout) return ssh
def test_credentials(hostname, username, password, port): """ Returns True if the credentials work """ client = SSHClient() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) try: client.connect(hostname, username=username, password=password, port=port) return True except Exception as e: print(e) return False
def test_keyfile(hostname, username, key_filename, port=22, timeout=15): """ Tests if a key file works """ client = SSHClient() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) try: client.connect( hostname, port=port, username=username, key_filename=key_filename, timeout=10) return True except Exception as e: print(e) return False
class Shared(object): def __init__(self, args): self.args = args self.client = Client( 'http://{0}{1}'.format(self.args.address, ':{0}'.format(self.args.port) if self.args.port else ''), '/api/v2.0/', username=self.args.username, password=self.args.password, ) self.ssh_client = SSHClient() self.ssh_client.set_missing_host_key_policy(AutoAddPolicy()) self.ssh_client.connect(args.address, port=args.sshport, username=args.username, password=args.password)
def ssh_instance_pass(step, instance_name, password): out = bash('ssh %s -A -f -L 11112:%s:22 root@%s -N' % (SSH_OPTS, world.instances[instance_name]['ip'], config['cloud']['master'])) if out.successful(): from paramiko.client import SSHClient client = SSHClient() client.load_system_host_keys() client.connect('localhost', username='******', password=password, port=11112) #stdin, stdout, stderr = client.exec_command('hostname') client.exec_command('hostname') print 'done' client.close()
def stop_instance(instance): try: stop_script_location = instance.tags['stop_script'] except KeyError: stop_script_location = '~/shutdown.sh' client = SSHClient() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) client.load_system_host_keys() client.connect(instance.ip_address, username="******") stdin, stdout, stderr = client.exec_command('%s "%s" "%s"' % (stop_script_location, app.config["API_KEY"], app.config["MY_URL"] + "/api/v1/stats")) try: for s in [stdin, stdout, stderr]: app.logger.info(s.read()) except IOError: pass client.close()
def sshClient(self): if self._sshClient is None: self.loadSshConfig() self._sshClient = SSHClient() self._sshClient.set_missing_host_key_policy(AutoAddPolicy()) self._sshClient.connect(self.hostname, self.sshPort, self.sshUser, key_filename=self.sshKey, timeout=10) return self._sshClient
def __init__(self): self.client = SSHClient() self.client.load_system_host_keys() self.client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) config = ConfigParser.ConfigParser() config.read("/home/forlinux/www/4803-Python/ProjetoDexter/config.cfg") self.client.connect(config.get("docker","address"))
def initSSHClient(self): """ Tries to establish connection with the host. @raise SSHException: if the connection could not be established. """ self.client = None waitPeriod = 10 attempts = 10 # Try to connect but not more than attempts times for iteration in range(attempts): # If not the first time - sleep a bit. Do not bombard the server with requests if iteration > 0: time.sleep(waitPeriod) # Try establishing ssh client try: self.client = SSHClient() self.client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) if self.pemFile is not None: self.client.connect(self.address, username=self.userName, key_filename=self.pemFile, timeout=self.timeout) else : self.client.connect(self.address, username=self.userName, password=self.password, timeout=self.timeout) break except (SSHException, socket.error) as e: self.client = None log.error("Could not connect to host %s err: %s", self.readableName, str(e)) # If we could not connect several times - throw an exception if self.client == None: raise SSHException('Could not connect ' + str(attempts) + ' times in a row')
def __init__(self): self.client = SSHClient() self.client.load_host_keys(settings.FDS_HOST_KEY) self.client.connect(settings.FDS_HOST, username=settings.FDS_USER, key_filename=settings.FDS_PRIVATE_KEY, port=settings.FDS_PORT) self.sftp = self.client.open_sftp() log.info("Connected to FDS")
class RemoteRunner(Runner): def __init__(self, *args, **kwargs): super(RemoteRunner, self).__init__(*args, **kwargs) self.context def start(self, command): 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.context.remote_runner.hostname, username=self.context.remote_runner.username) self.ssh_channel = self.ssh_client.get_transport().open_session() if self.using_pty: self.ssh_channel.get_pty() self.ssh_channel.exec_command(command) def stdout_reader(self): return self.ssh_channel.recv def stderr_reader(self): return self.ssh_channel.recv_stderr def default_encoding(self): return locale.getpreferredencoding(True) def wait(self): return self.ssh_channel.recv_exit_status() def returncode(self): return self.ssh_channel.recv_exit_status()
def start(self, command): 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.context.remote_runner.hostname, username=self.context.remote_runner.username) self.ssh_channel = self.ssh_client.get_transport().open_session() if self.using_pty: self.ssh_channel.get_pty() self.ssh_channel.exec_command(command)
def connection(self): try: connection = self.ssh_connection self.log.info('Determining is SSH transport is still active') transport = connection.get_transport() if not transport.is_active(): self.log.warn('SSH transport is no longer active') self.log.info('Proceeding to re-establish SSH connection') raise Exception() else: self.log.info('SSH transport is still active') return connection except Exception: pass connection = SSHClient() connection.set_missing_host_key_policy(AutoAddPolicy()) self.log.info('Attempting to establish SSH connection') while True: try: keys = ['~/.ssh/stage', '~/.ssh/prod'] keys = [os.path.expanduser(key) for key in keys] connection.connect(self.instance.private_dns_name, username='******', key_filename=keys) break except Exception: self.log.warn('Unable to establish SSH connection') time.sleep(10) self.log.info('Successfully established SSH connection') self.ssh_connection = connection return connection
def _get_ssh_connection(self): """Returns an ssh connection to the specified host""" _timeout = True ssh = SSHClient() ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) _start_time = time.time() saved_exception = exceptions.StandardError() #doing this because the log file fills up with these messages #this way it only logs it once log_attempted = False socket_error_logged = False auth_error_logged = False ssh_error_logged = False while not self._is_timed_out(self.timeout, _start_time): try: if not log_attempted: self._log.debug('Attempting to SSH connect to: ') self._log.debug('host: %s, username: %s, password: %s' % (self.host, self.username, self.password)) log_attempted = True ssh.connect(hostname=self.host, username=self.username, password=self.password, timeout=20, key_filename=[], look_for_keys=False, allow_agent=False) _timeout = False break except socket.error as e: if not socket_error_logged: self._log.error('Socket Error: %s' % str(e)) socket_error_logged = True saved_exception = e continue except paramiko.AuthenticationException as e: if not auth_error_logged: self._log.error('Auth Exception: %s' % str(e)) auth_error_logged = True saved_exception = e time.sleep(2) continue except paramiko.SSHException as e: if not ssh_error_logged: self._log.error('SSH Exception: %s' % str(e)) ssh_error_logged = True saved_exception = e time.sleep(2) continue #Wait 2 seconds otherwise time.sleep(2) if _timeout: self._log.error('SSHConnector timed out while trying to establish a connection') raise saved_exception #This MUST be done because the transport gets garbage collected if it #is not done here, which causes the connection to close on invoke_shell #which is needed for exec_shell_command ResourceManager.register(self, ssh.get_transport()) return ssh
def connect(self, instance, ssh_user, ssh_ports, cmd, ssh_key_name): """ execute a command on instance with ssh and return if cmd param is not None connect to ssh if cmd is None :param instance: :param ssh_user: :param ssh_ports: :param ssh_key_name: :param cmd: execute this command if not None :return: """ # get instance public ip ssh_ip = instance.ip # we need to find the ssh key try: key_file = open(os.path.join(os.path.expanduser(self._key_path), ssh_key_name), 'r') except FileNotFoundError: try: key_file = open(os.path.join(os.path.expanduser(self._key_path), ssh_key_name + '.pem'), 'r') except FileNotFoundError: raise CourirSshException('private key %(key_name)s nor %(key_name)s.pem not found' % { 'key_name': ssh_key_name }) client = SSHClient() client.set_missing_host_key_policy(AutoAddPolicy()) logger.debug('connecting to %s with port %s and user %s', ssh_ip, ssh_ports[0], ssh_user) mykey = RSAKey.from_private_key(key_file) # we try with each ssh_port we have for count, ssh_port in enumerate(ssh_ports): try: logger.debug(ssh_ip) logger.debug(ssh_port) client.connect(hostname=ssh_ip, port=int(ssh_port), username=ssh_user, pkey=mykey, timeout=4) if cmd is None: with NamedTemporaryFile(mode='w+') as tmp_key_file: mykey.write_private_key(tmp_key_file, password=None) tmp_key_file.flush() cmd = 'ssh -i %s %s@%s -p %s' % (tmp_key_file.name, ssh_user, ssh_ip, ssh_port) logger.debug(cmd) os.system(cmd) else: stdin, stdout, stderr = client.exec_command(command=cmd) out_str = stdout.read() out_err = stderr.read().strip(' \t\n\r') print(out_str) if out_err != '': print(out_err) sys.exit(1) except (ConnectionRefusedError, socket.timeout): # we will try another tcp port if count < len(ssh_ports): continue else: raise CourirSshException('connection error')
def _connect(self): client = SSHClient() client.load_system_host_keys() client.set_missing_host_key_policy(AutoAddPolicy()) try: client.connect(hostname=self.host, port=self.port, username=self.user, password=self.passwd, timeout=3) self.closed = False return client except AuthenticationException, e: return e
def __init__(self): # Remote path for saving all resources self.base_folder = settings.SFTP_DATASTORE_REMOTEBASEFOLDER # Local base folder for saving temporary files before upload self.tmp_folder = settings.SFTP_DATASTORE_LOCALTMPFOLDER # url for donwloading resources self.public_base_url = settings.SFTP_BASE_URL self.buckets = [] self.connection = None self.ssh_client = SSHClient() self.ssh_client.set_missing_host_key_policy(AutoAddPolicy()) self.ssh_client.load_system_host_keys() self.sftp = None
def configure_cfme(ipaddr, ssh_username, ssh_password, region, db_password): cmd = "appliance_console_cli --region %s --internal --force-key -p %s" % (region, db_password) client = SSHClient() try: client.set_missing_host_key_policy(AutoAddPolicy()) client.connect(ipaddr, username=ssh_username, password=ssh_password, allow_agent=False) print "Will run below command on host: %s" % (ipaddr) print cmd stdin, stdout, stderr = client.exec_command(cmd) status = stdout.channel.recv_exit_status() out = stdout.readlines() err = stderr.readlines() return status, out, err finally: client.close()
def executar_comando_remoto(com): hosts = ["192.168.0.2"] ssh = SSHClient() ssh.load_system_host_keys() ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) for h in hosts: try: ssh.connect(h) stdin,stdout,stderr = ssh.exec_command(com) if stderr.channel.recv_exit_status() != 0: print stderr.read() else: print stdout.read() except Exception as e: print "Nao conseguiu conectar ao servidor %s"%e
class FDSConnection(): def __init__(self): self.client = SSHClient() self.client.load_host_keys(settings.FDS_HOST_KEY) self.client.connect(settings.FDS_HOST, username=settings.FDS_USER, key_filename=settings.FDS_PRIVATE_KEY, port=settings.FDS_PORT) self.sftp = self.client.open_sftp() log.info("Connected to FDS") def get_files(self): log.info("Receiving files from FDS...") fds_data_path = os.path.join(settings.BASE_DIR, settings.FDS_DATA_PATH) local_files = os.listdir(fds_data_path) self.sftp.chdir('yellow-net-reports') for file in self.sftp.listdir(): if file not in local_files and file + '.processed' not in local_files: log.info("Receiving {}".format(file)) self.sftp.get(file, os.path.join(fds_data_path, file)) # self.sftp.remove(file) else: log.debug("Skipping already present file: {}".format(file))
def timecheck(h): cmd = "sudo sysctl -w net.core.somaxconn=16000;" s = SSHClient() print "> %s" % (h,) s.set_missing_host_key_policy(AutoAddPolicy()) s.connect(hostname=h[1], username=h[0])#, password='') (_in, _out, _err) = s.exec_command( cmd, bufsize=4096) print "< %s" % (h,) return (h,_out.read())
class datastore_sftp(datastore): """ collect of independent functions, not really a Class """ def __init__(self): # Remote path for saving all resources self.base_folder = settings.SFTP_DATASTORE_REMOTEBASEFOLDER # Local base folder for saving temporary files before upload self.tmp_folder = settings.SFTP_DATASTORE_LOCALTMPFOLDER # url for donwloading resources self.public_base_url = settings.SFTP_BASE_URL self.buckets = [] self.connection = None self.ssh_client = SSHClient() self.ssh_client.set_missing_host_key_policy(AutoAddPolicy()) self.ssh_client.load_system_host_keys() self.sftp = None def connect(self): """ don't use at INIT because it hangs all application""" logger = logging.getLogger(__name__) logger.error('Connecting SFTP %s:%s (%s, %s)' %( settings.SFTP_DATASTORE_HOSTNAME, settings.SFTP_DATASTORE_PORT, settings.SFTP_DATASTORE_USER, settings.SFTP_DATASTORE_PASSWORD) ) # TODO: Remove con = sftp.Connection( host=settings.SFTP_DATASTORE_HOSTNAME, port=settings.SFTP_DATASTORE_PORT, username=settings.SFTP_DATASTORE_USER, password=settings.SFTP_DATASTORE_PASSWORD, log=True ) self.connection = con # self.ssh_client.connect( settings.SFTP_DATASTORE_HOSTNAME, port=settings.SFTP_DATASTORE_PORT, username=settings.SFTP_DATASTORE_USER, password=settings.SFTP_DATASTORE_PASSWORD ) self.sftp = self.ssh_client.open_sftp() # list all buckets (folders) try: self.buckets = self.sftp.listdir(path=self.base_folder) logger.error('Buckets: %s' %str(self.buckets)) except Exception, e: logger.error('Error Connecting SFTP %s' % str(e)) self.sftp.close()
from paramiko.client import SSHClient get_temp_cmd = 'bash /home/pi/Documents/gitProjects/icypi/src/mcp9808/get_temp_mcp9808.sh' client = SSHClient() client.load_system_host_keys() client.connect('192.168.101.109', username='******') stdin, stdout, stderr = client.exec_command(get_temp_cmd) lines = stdout.readlines() temp = float(lines[0].strip()) print(temp)
def ssh_paramiko_connect_to(display_desc): #plain socket attributes: dtype = display_desc["type"] host = display_desc["host"] port = display_desc.get("ssh-port", 22) #ssh and command attributes: username = display_desc.get("username") or get_username() if "proxy_host" in display_desc: display_desc.setdefault("proxy_username", get_username()) password = display_desc.get("password") target = ssh_target_string(display_desc) remote_xpra = display_desc["remote_xpra"] proxy_command = display_desc["proxy_command"] #ie: "_proxy_start" socket_dir = display_desc.get("socket_dir") display_as_args = display_desc["display_as_args"] #ie: "--start=xterm :10" socket_info = { "host": host, "port": port, } with nogssapi_context(): from paramiko import SSHConfig, ProxyCommand ssh_config = SSHConfig() user_config_file = os.path.expanduser("~/.ssh/config") sock = None host_config = None if os.path.exists(user_config_file): with open(user_config_file) as f: ssh_config.parse(f) host_config = ssh_config.lookup(host) if host_config: host = host_config.get("hostname", host) username = host_config.get("username", username) port = host_config.get("port", port) proxycommand = host_config.get("proxycommand") if proxycommand: sock = ProxyCommand(proxycommand) from xpra.child_reaper import getChildReaper cmd = getattr(sock, "cmd", []) getChildReaper().add_process(sock.process, "paramiko-ssh-client", cmd, True, True) log("found proxycommand='%s' for host '%s'", proxycommand, host) from paramiko.client import SSHClient ssh_client = SSHClient() ssh_client.load_system_host_keys() ssh_client.connect(host, port, sock=sock) transport = ssh_client.get_transport() do_ssh_paramiko_connect_to( transport, host, username, password, host_config or ssh_config.lookup("*")) chan = paramiko_run_remote_xpra(transport, proxy_command, remote_xpra, socket_dir, display_as_args) peername = (host, port) conn = SSHProxyCommandConnection(chan, peername, target, socket_info) conn.timeout = SOCKET_TIMEOUT conn.start_stderr_reader() conn.process = (sock.process, "ssh", cmd) from xpra.net import bytestreams from paramiko.ssh_exception import ProxyCommandFailure bytestreams.CLOSED_EXCEPTIONS = tuple( list(bytestreams.CLOSED_EXCEPTIONS) + [ProxyCommandFailure]) return conn from xpra.scripts.main import socket_connect from paramiko.transport import Transport from paramiko import SSHException if "proxy_host" in display_desc: proxy_host = display_desc["proxy_host"] proxy_port = display_desc.get("proxy_port", 22) proxy_username = display_desc.get("proxy_username", username) proxy_password = display_desc.get("proxy_password", password) sock = socket_connect(dtype, proxy_host, proxy_port) middle_transport = Transport(sock) middle_transport.use_compression(False) try: middle_transport.start_client() except SSHException as e: log("start_client()", exc_info=True) raise InitException("SSH negotiation failed: %s" % e) proxy_host_config = ssh_config.lookup(host) do_ssh_paramiko_connect_to( middle_transport, proxy_host, proxy_username, proxy_password, proxy_host_config or ssh_config.lookup("*")) log("Opening proxy channel") chan_to_middle = middle_transport.open_channel( "direct-tcpip", (host, port), ('localhost', 0)) transport = Transport(chan_to_middle) transport.use_compression(False) try: transport.start_client() except SSHException as e: log("start_client()", exc_info=True) raise InitException("SSH negotiation failed: %s" % e) do_ssh_paramiko_connect_to(transport, host, username, password, host_config or ssh_config.lookup("*")) chan = paramiko_run_remote_xpra(transport, proxy_command, remote_xpra, socket_dir, display_as_args) peername = (host, port) conn = SSHProxyCommandConnection(chan, peername, target, socket_info) conn.timeout = SOCKET_TIMEOUT conn.start_stderr_reader() return conn #plain TCP connection to the server, #we open it then give the socket to paramiko: sock = socket_connect(dtype, host, port) sockname = sock.getsockname() peername = sock.getpeername() log("paramiko socket_connect: sockname=%s, peername=%s", sockname, peername) transport = Transport(sock) transport.use_compression(False) try: transport.start_client() except SSHException as e: log("start_client()", exc_info=True) raise InitException("SSH negotiation failed: %s" % e) do_ssh_paramiko_connect_to(transport, host, username, password, host_config or ssh_config.lookup("*")) chan = paramiko_run_remote_xpra(transport, proxy_command, remote_xpra, socket_dir, display_as_args) conn = SSHSocketConnection(chan, sock, sockname, peername, target, socket_info) conn.timeout = SOCKET_TIMEOUT conn.start_stderr_reader() return conn
class SSH: def __init__(self, hostname, port=22, username='******', pkey=None, password=None, default_env=None, connect_timeout=10): self.stdout = None self.client = None self.channel = None self.sftp = None self.eof = 'Spug EOF 2108111926' self.already_init = False self.default_env = self._make_env_command(default_env) self.regex = re.compile(r'Spug EOF 2108111926 (-?\d+)[\r\n]?') self.arguments = { 'hostname': hostname, 'port': port, 'username': username, 'password': password, 'pkey': RSAKey.from_private_key(StringIO(pkey)) if isinstance(pkey, str) else pkey, 'timeout': connect_timeout, 'banner_timeout': 30 } @staticmethod def generate_key(): key_obj = StringIO() key = RSAKey.generate(2048) key.write_private_key(key_obj) return key_obj.getvalue(), 'ssh-rsa ' + key.get_base64() def get_client(self): if self.client is not None: return self.client self.client = SSHClient() self.client.set_missing_host_key_policy(AutoAddPolicy) self.client.connect(**self.arguments) return self.client def ping(self): return True def add_public_key(self, public_key): command = f'mkdir -p -m 700 ~/.ssh && \ echo {public_key!r} >> ~/.ssh/authorized_keys && \ chmod 600 ~/.ssh/authorized_keys' exit_code, out = self.exec_command_raw(command) if exit_code != 0: raise Exception(f'add public key error: {out}') def exec_command_raw(self, command, environment=None): channel = self.client.get_transport().open_session() if environment: channel.update_environment(environment) channel.set_combine_stderr(True) channel.exec_command(command) code, output = channel.recv_exit_status(), channel.recv(-1) return code, self._decode(output) def exec_command(self, command, environment=None): channel = self._get_channel() command = self._handle_command(command, environment) channel.send(command) out, exit_code = '', -1 for line in self.stdout: match = self.regex.search(line) if match: exit_code = int(match.group(1)) line = line[:match.start()] out += line break out += line return exit_code, out def _win_exec_command_with_stream(self, command, environment=None): channel = self.client.get_transport().open_session() if environment: channel.update_environment(environment) channel.set_combine_stderr(True) channel.get_pty(width=102) channel.exec_command(command) stdout = channel.makefile("rb", -1) out = stdout.readline() while out: yield channel.exit_status, self._decode(out) out = stdout.readline() yield channel.recv_exit_status(), self._decode(out) def exec_command_with_stream(self, command, environment=None): channel = self._get_channel() command = self._handle_command(command, environment) channel.send(command) exit_code, line = -1, '' while True: line = self._decode(channel.recv(8196)) if not line: break match = self.regex.search(line) if match: exit_code = int(match.group(1)) line = line[:match.start()] break yield exit_code, line yield exit_code, line def put_file(self, local_path, remote_path): sftp = self._get_sftp() sftp.put(local_path, remote_path) def put_file_by_fl(self, fl, remote_path, callback=None): sftp = self._get_sftp() sftp.putfo(fl, remote_path, callback=callback) def list_dir_attr(self, path): sftp = self._get_sftp() return sftp.listdir_attr(path) def sftp_stat(self, path): sftp = self._get_sftp() return sftp.stat(path) def remove_file(self, path): sftp = self._get_sftp() sftp.remove(path) def _get_channel(self): if self.channel: return self.channel counter = 0 self.channel = self.client.invoke_shell() command = 'set +o zle\nset -o no_nomatch\nexport PS1= && stty -echo\n' if self.default_env: command += f'{self.default_env}\n' command += f'echo {self.eof} $?\n' self.channel.send(command.encode()) while True: if self.channel.recv_ready(): line = self._decode(self.channel.recv(8196)) if self.regex.search(line): self.stdout = self.channel.makefile('r') break elif counter >= 100: self.client.close() raise Exception('Wait spug response timeout') else: counter += 1 time.sleep(0.1) return self.channel def _get_sftp(self): if self.sftp: return self.sftp self.sftp = self.client.open_sftp() return self.sftp def _make_env_command(self, environment): if not environment: return None str_envs = [] for k, v in environment.items(): k = k.replace('-', '_') if isinstance(v, str): v = v.replace("'", "'\"'\"'") str_envs.append(f"{k}='{v}'") str_envs = ' '.join(str_envs) return f'export {str_envs}' def _handle_command(self, command, environment): new_command = commands = '' if not self.already_init: commands = 'export SPUG_EXEC_FILE=$(mktemp)\n' commands += 'trap \'rm -f $SPUG_EXEC_FILE\' EXIT\n' self.already_init = True env_command = self._make_env_command(environment) if env_command: new_command += f'{env_command}\n' new_command += command new_command += f'\necho {self.eof} $?\n' b64_command = base64.standard_b64encode(new_command.encode()) commands += f'echo {b64_command.decode()} | base64 -di > $SPUG_EXEC_FILE\n' commands += 'source $SPUG_EXEC_FILE\n' return commands def _decode(self, content): try: content = content.decode() except UnicodeDecodeError: content = content.decode(encoding='GBK', errors='ignore') return content def __enter__(self): self.get_client() transport = self.client.get_transport() if 'windows' in transport.remote_version.lower(): self.exec_command = self.exec_command_raw self.exec_command_with_stream = self._win_exec_command_with_stream return self def __exit__(self, exc_type, exc_val, exc_tb): self.client.close() self.client = None
from paramiko.client import SSHClient # Credentials here are for a always-on Sandbox from Cisco DevNet SSH_USER = "******" SSH_PASSWORD = "******" SSH_HOST = "<Insert the IP/host of your device/server here>" SSH_PORT = 22 # Change this if your SSH port is different client = SSHClient() client.load_system_host_keys() try: client.connect(SSH_HOST, port=SSH_PORT, username=SSH_USER, password=SSH_PASSWORD, look_for_keys=False) print("Connected succesfully!") except Exception: print("Failed to establish connection.") finally: client.close()
def connect_v2(host,port,username,password=None,private_key=None,config_path=None): """ Note: it may be possible to escalate root priveleges stdin,stdout,stderr = ssh.exec_command("sudo su; whoami", get_pty=True) various strategies exist for entering the password. """ # build a configuration from the options cfg = {"hostname":host, "port":port, "username":username, "timeout":10.0,"compress":True, "allow_agent":False, "look_for_keys":False} if password is not None: cfg["password"] = password user_config = getSSHConfig(config_path,host) # copy the settings from the userconfig, overwriting the cfg. for k in ('hostname', 'username', 'port'): if k in user_config: cfg[k] = user_config[k] # proxy command allows for two factor authentication if 'proxycommand' in user_config: cfg['sock'] = paramiko.ProxyCommand(user_config['proxycommand']) cfg['timeout'] = 45.0; # give extra time for two factor print(cfg) cfg['pkey'] = None if private_key: # non-null, non-empty passphrase = "" # TODO: support passphrases cfg['pkey']=paramiko.RSAKey.from_private_key_file(\ private_key,passphrase) client = SSHClient() client.load_system_host_keys() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) #client.set_missing_host_key_policy(paramiko.WarningPolicy()) try: client.connect(**cfg) except BadHostKeyException as e: sys.stderr.write("got: %s\n"%e.key.asbytes()); sys.stderr.write("expected: %s\n"%e.expected_key.asbytes()); msg = "Connection error on %s:%s using privatekey=%s\n"%(\ host,port,private_key) msg += "you may need to clear ~/.ssh/known_hosts "+\ "for entries related to %s:%s\n"%(host,port); sys.stderr.write(msg); raise Exception(msg); src = SSHClientSource() src.client = client src.ftp = client.open_sftp() src.host=host src.port=port src.config=cfg return src
def turn_off(id): server = SERVERS.get(id) if not server: return server_not_found() exit_status = -1 ssh_settings = server['ssh'] client = SSHClient() client.load_system_host_keys() client.set_missing_host_key_policy(AutoAddPolicy()) client.connect(ssh_settings['address'], username=ssh_settings['username'], password=ssh_settings['password']) stdin, stdout, stderr = client.exec_command('shutdown -p now') #print("stdout: " + str(stdout.readlines())) #print("stderr: " + str(stderr.readlines())) exit_status = stdout.channel.recv_exit_status() print("Shutdown, exit status: %s" % exit_status) client.close() return jsonify({"success": exit_status == 0})
import json from paramiko.client import SSHClient credentials = {} with open("credentials.json") as fh: json.load(fh) CMD = “show running-config” for cred in credentials: out_file_name = str(cred['name']) + ".txt" client = SSHClient() client.load_system_host_keys() client.connect(SSH_HOST, port=cred['port'], username=cred['username'], password=cred['password']) stdin, stdout, stderr = client.exec_command(CMD) out_file = open(out_file_name, "w") output = stdout.readlines() for line in output: out_file.write(line) out_file.close() client.close() print("Executed command on " + cred['name'])
def __init__(self): self.ssh_client = SSHClient()
print("A kinto.fcgi already exist.") else: print("A kinto.fcgi has been uploaded.") try: with open("htaccess", "rb") as f: ftp.storbinary("STOR www/.htaccess", f) except ftplib.error_perm: print("A .htaccess already exist.") else: print("A .htaccess has been uploaded.") ftp.close() # Install kinto[postgresql] ssh = SSHClient() ssh.set_missing_host_key_policy(AutoAddPolicy()) ssh.connect(settings['ssh_host'], username=settings['prefixed_username'], password=PASSWORD, look_for_keys=False) stdin, stdout, stderr = ssh.exec_command('PYTHONPATH=~/.local/ easy_install-2.6 --install-dir=~/.local -U pip') print(stdout.read(), stderr.read()) stdin, stdout, stderr = ssh.exec_command('PYTHONPATH=~/.local/ ~/.local/pip install --user --no-binary --upgrade setuptools virtualenv virtualenvwrapper') print(stdout.read(), stderr.read()) stdin, stdout, stderr = ssh.exec_command('~/.local/bin/virtualenv kinto/venv/ --python=python2.7') print(stdout.read(), stderr.read()) stdin, stdout, stderr = ssh.exec_command('kinto/venv/bin/pip install kinto[postgresql] kinto-attachment flup') print(stdout.read(), stderr.read()) # Run kinto migration to setup the database. stdin, stdout, stderr = ssh.exec_command('kinto/venv/bin/kinto --ini kinto/kinto.ini migrate') print(stdout.read(), stderr.read())
def __init__( self, host, user=None, port=None, config=None, gateway=None, forward_agent=None, connect_timeout=None, connect_kwargs=None, ): """ Set up a new object representing a server connection. :param str host: the hostname (or IP address) of this connection. May include shorthand for the ``user`` and/or ``port`` parameters, of the form ``user@host``, ``host:port``, or ``user@host:port``. .. note:: Due to ambiguity, IPv6 host addresses are incompatible with the ``host:port`` shorthand (though ``user@host`` will still work OK). In other words, the presence of >1 ``:`` character will prevent any attempt to derive a shorthand port number; use the explicit ``port`` parameter instead. .. note:: If ``host`` matches a ``Host`` clause in loaded SSH config data, and that ``Host`` clause contains a ``Hostname`` directive, the resulting `.Connection` object will behave as if ``host`` is equal to that ``Hostname`` value. In all cases, the original value of ``host`` is preserved as the ``original_host`` attribute. Thus, given SSH config like so:: Host myalias Hostname realhostname a call like ``Connection(host='myalias')`` will result in an object whose ``host`` attribute is ``realhostname``, and whose ``original_host`` attribute is ``myalias``. :param str user: the login user for the remote connection. Defaults to ``config.user``. :param int port: the remote port. Defaults to ``config.port``. :param config: configuration settings to use when executing methods on this `.Connection` (e.g. default SSH port and so forth). Should be a `.Config` or an `invoke.config.Config` (which will be turned into a `.Config`). Default is an anonymous `.Config` object. :param gateway: An object to use as a proxy or gateway for this connection. This parameter accepts one of the following: - another `.Connection` (for a ``ProxyJump`` style gateway); - a shell command string (for a ``ProxyCommand`` style style gateway). Default: ``None``, meaning no gatewaying will occur (unless otherwise configured; if one wants to override a configured gateway at runtime, specify ``gateway=False``.) .. seealso:: :ref:`ssh-gateways` :param bool forward_agent: Whether to enable SSH agent forwarding. Default: ``config.forward_agent``. :param int connect_timeout: Connection timeout, in seconds. Default: ``config.timeouts.connect``. :param dict connect_kwargs: Keyword arguments handed verbatim to `SSHClient.connect <paramiko.client.SSHClient.connect>` (when `.open` is called). `.Connection` tries not to grow additional settings/kwargs of its own unless it is adding value of some kind; thus, ``connect_kwargs`` is currently the right place to hand in parameters such as ``pkey`` or ``key_filename``. Default: ``config.connect_kwargs``. :raises ValueError: if user or port values are given via both ``host`` shorthand *and* their own arguments. (We `refuse the temptation to guess`_). .. _refuse the temptation to guess: http://zen-of-python.info/ in-the-face-of-ambiguity-refuse-the-temptation-to-guess.html#12 """ # NOTE: parent __init__ sets self._config; for now we simply overwrite # that below. If it's somehow problematic we would want to break parent # __init__ up in a manner that is more cleanly overrideable. super(Connection, self).__init__(config=config) #: The .Config object referenced when handling default values (for e.g. #: user or port, when not explicitly given) or deciding how to behave. if config is None: config = Config() # Handle 'vanilla' Invoke config objects, which need cloning 'into' one # of our own Configs (which grants the new defaults, etc, while not # squashing them if the Invoke-level config already accounted for them) elif not isinstance(config, Config): config = config.clone(into=Config) self._set(_config=config) # TODO: when/how to run load_files, merge, load_shell_env, etc? # TODO: i.e. what is the lib use case here (and honestly in invoke too) shorthand = self.derive_shorthand(host) host = shorthand["host"] err = ( "You supplied the {} via both shorthand and kwarg! Please pick one." # noqa ) if shorthand["user"] is not None: if user is not None: raise ValueError(err.format("user")) user = shorthand["user"] if shorthand["port"] is not None: if port is not None: raise ValueError(err.format("port")) port = shorthand["port"] # NOTE: we load SSH config data as early as possible as it has # potential to affect nearly every other attribute. #: The per-host SSH config data, if any. (See :ref:`ssh-config`.) self.ssh_config = self.config.base_ssh_config.lookup(host) self.original_host = host #: The hostname of the target server. self.host = host if "hostname" in self.ssh_config: # TODO: log that this occurred? self.host = self.ssh_config["hostname"] #: The username this connection will use to connect to the remote end. self.user = user or self.ssh_config.get("user", self.config.user) # TODO: is it _ever_ possible to give an empty user value (e.g. # user='')? E.g. do some SSH server specs allow for that? #: The network port to connect on. self.port = port or int(self.ssh_config.get("port", self.config.port)) # Non-None values - string, Connection, even eg False - get set # directly; None triggers seek in config/ssh_config if gateway is None: # SSH config wins over Invoke-style config if "proxyjump" in self.ssh_config: # Reverse hop1,hop2,hop3 style ProxyJump directive so we start # with the final (itself non-gatewayed) hop and work up to # the front (actual, supplied as our own gateway) hop hops = reversed(self.ssh_config["proxyjump"].split(",")) prev_gw = None for hop in hops: # Happily, ProxyJump uses identical format to our host # shorthand... if prev_gw is None: # TODO: this isn't persisting config! which among other # things can lead to not honoring skipping ssh config # file loads... cxn = Connection(hop) else: cxn = Connection(hop, gateway=prev_gw) prev_gw = cxn gateway = prev_gw elif "proxycommand" in self.ssh_config: # Just a string, which we interpret as a proxy command.. gateway = self.ssh_config["proxycommand"] else: # Neither of those? Our config value please. gateway = self.config.gateway #: The gateway `.Connection` or ``ProxyCommand`` string to be used, #: if any. self.gateway = gateway # NOTE: we use string above, vs ProxyCommand obj, to avoid spinning up # the ProxyCommand subprocess at init time, vs open() time. # TODO: make paramiko.proxy.ProxyCommand lazy instead? if forward_agent is None: # Default to config... forward_agent = self.config.forward_agent # But if ssh_config is present, it wins if "forwardagent" in self.ssh_config: # TODO: SSHConfig really, seriously needs some love here, god map_ = {"yes": True, "no": False} forward_agent = map_[self.ssh_config["forwardagent"]] #: Whether agent forwarding is enabled. self.forward_agent = forward_agent if connect_timeout is None: connect_timeout = self.ssh_config.get("connecttimeout", self.config.timeouts.connect) if connect_timeout is not None: connect_timeout = int(connect_timeout) #: Connection timeout self.connect_timeout = connect_timeout #: Keyword arguments given to `paramiko.client.SSHClient.connect` when #: `open` is called. self.connect_kwargs = self.resolve_connect_kwargs(connect_kwargs) #: The `paramiko.client.SSHClient` instance this connection wraps. client = SSHClient() client.set_missing_host_key_policy(AutoAddPolicy()) self.client = client #: A convenience handle onto the return value of #: ``self.client.get_transport()``. self.transport = None
def __init__(self): self.client = SSHClient() self.client.load_system_host_keys() self.client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) self.client.connect("192.168.0.2", username='******', password='******')
def install_kinto_remotely(id_alwaysdata, credentials, ssh_host, prefixed_username, status_handler): logs = StringIO() # SSH Login ssh = SSHClient() ssh.set_missing_host_key_policy(AutoAddPolicy()) ssh.connect(ssh_host, username=prefixed_username, password=credentials[1], look_for_keys=False) # Install pip stdin, stdout, stderr = ssh.exec_command( 'PYTHONPATH=~/.local/ easy_install-2.6 --install-dir=~/.local -U pip') logs.write(stdout.read()) logs.write(stderr.read()) status_handler.ssh_logs = logs # Install virtualenv stdin, stdout, stderr = ssh.exec_command( 'PYTHONPATH=~/.local/ ~/.local/pip install --user --no-binary --upgrade ' 'setuptools virtualenv virtualenvwrapper') logs.write(stdout.read()) logs.write(stderr.read()) status_handler.ssh_logs = logs # Create virtualenv stdin, stdout, stderr = ssh.exec_command( '~/.local/bin/virtualenv kinto/venv/ --python=python2.7') logs.write(stdout.read()) logs.write(stderr.read()) status_handler.ssh_logs = logs # Install Kinto in the virtualenv stdin, stdout, stderr = ssh.exec_command( 'kinto/venv/bin/pip install kinto[postgresql] kinto-attachment flup') logs.write(stdout.read()) logs.write(stderr.read()) status_handler.ssh_logs = logs # Run kinto migration to setup the database. stdin, stdout, stderr = ssh.exec_command( 'kinto/venv/bin/kinto --ini kinto/kinto.ini migrate') logs.write(stdout.read()) logs.write(stderr.read()) status_handler.ssh_logs = logs ssh.close()
def set_server(ip, port, n_conn, Tunnel, hostname=None, username=None): """ this method is responsible for establishing a server(listnening for connection) In a direct LAN enviroment if Tunnel was False; hostname isn't needed n_conn is the awaited number of connections to be established Hostname is needed it Tunnel was activated """ connection = [] transport = None if Tunnel: sshclient = SSHClient() sshclient.load_system_host_keys() sshclient.set_missing_host_key_policy(AutoAddPolicy()) try: sshclient.connect(hostname=hostname, username=username) except (BadHostKeyException, SSHException, AuthenticationException) as e: print("problem hapened ssh into {}".format(hostname)) raise e sshclient.get_transport().close() return None, None try: try: transport = sshclient.get_transport() port = transport.request_port_forward(address=ip, port=port) except (SSHException): print("the Node refused the Given port {}".format(port)) port = 0 port = transport.request_port_forward(address=ip, port=port) print("port {}".format(port)) print('starting up on {} : {}'.format(ip, port)) for i in range(n_conn): connection.append(transport.accept(None)) print('client_address is {}:{} '.format( *connection[i].getpeername())) except (BadHostKeyException, SSHException, AuthenticationException) as e: print( "an unexpected problem has been faced in request_port_forward") for i in connection: i.close() transport.close() return None, None #port,s=tunneling_cmd_hpc_server(user=user,path=path,local_port=port) else: #s = None sock = socket.socket( socket.AF_INET, socket.SOCK_STREAM ) #specifying socket type is IPV4"socket.AF_INET" and TCP "SOCK_STREAM" server_address = (ip, port) # saving ip and port as tuple try: sock.bind(server_address) # attaching the socket to the pc (code) print('starting up on', server_address[0], ':', server_address[1]) sock.listen(n_conn) # start waiting for 1 client to connection for i in range(n_conn): connection_, client_address = sock.accept( ) #accepting that client and hosting a connection with him print('client_address is {}:{} '.format(*client_address)) connection.append(connection_) except (OSError) as e: print("Making a server Failed") raise e for i in connection: i.close() return None, None print('The number of connections started successfully = {}'.format( n_conn)) # printing when the connection is successful return connection, transport #returning the connection object for further use
def ssh(host, forward_agent=False, sudoable=False, max_attempts=1, max_timeout=5, ssh_password=None): """Manages a SSH connection to the desired host. Will leverage your ssh config at ~/.ssh/config if available :param host: the server to connect to :type host: str :param forward_agent: forward the local agents :type forward_agent: bool :param sudoable: allow sudo commands :type sudoable: bool :param max_attempts: the maximum attempts to connect to the desired host :type max_attempts: int :param max_timeout: the maximum timeout in seconds to sleep between attempts :type max_timeout: int :param ssh_password: SSH password to use if needed :type ssh_password: str :returns a SSH connection to the desired host :rtype: Connection :raises MaxConnectionAttemptsError: Exceeded the maximum attempts to establish the SSH connection. """ with closing(SSHClient()) as client: client.set_missing_host_key_policy(AutoAddPolicy()) cfg = { "hostname": host, "timeout": max_timeout, } if ssh_password: cfg['password'] = ssh_password ssh_config = SSHConfig() user_config_file = os.path.expanduser("~/.ssh/config") if os.path.exists(user_config_file): with open(user_config_file) as f: ssh_config.parse(f) host_config = ssh_config.lookup(host) if "user" in host_config: cfg["username"] = host_config["user"] if "proxycommand" in host_config: cfg["sock"] = ProxyCommand(host_config["proxycommand"]) if "identityfile" in host_config: cfg['key_filename'] = host_config['identityfile'] if "port" in host_config: cfg["port"] = int(host_config["port"]) attempts = 0 while attempts < max_attempts: try: attempts += 1 client.connect(**cfg) break except socket.error as e: if attempts < max_attempts: print("SSH to host {0} failed, retrying...".format(host)) time.sleep(max_timeout) else: print("SSH Exception: {0}".format(e)) else: raise MaxConnectionAttemptsError( "Exceeded max attempts to connect to host {0} after {1} retries" .format(host, max_attempts)) yield Connection(client, forward_agent, sudoable)
def connect_via_ssh(host, ssh_user, ssh_key_path): client = SSHClient() client.load_system_host_keys() client.connect(host, username=ssh_user, key_filename=ssh_key_path, allow_agent=False, look_for_keys=False, disabled_algorithms=dict(pubkeys=['rsa-sha2-512', 'rsa-sha2-256'])) return client
files = [] t0 = datetime.datetime.now() while True: while sys.stdin in select.select([sys.stdin], [], [], 0)[0]: line = sys.stdin.readline() files.append(line) size = len(files) if size: now = datetime.datetime.now() delta = now - t0 if 5.0 < delta.total_seconds(): runner = DirSync(args.remote_host, files) runner.main() if args.post_sync: print "Running ({cmd})".format(cmd=args.post_sync) with closing(SSHClient()) as client: client.load_system_host_keys() client.set_missing_host_key_policy(AutoAddPolicy()) print "Attempting to connect" client.connect(args.remote_host, allow_agent=True, username=os.getenv('USER')) print "Connected" with closing( client.get_transport().open_session()) as chan: chan.set_combine_stderr(True) chan.exec_command(args.post_sync) dump_channel(chan) rv = chan.recv_exit_status() print "Remote command exited with {rv}".format( rv=rv)
class SSH: def __init__(self, hostname, port=SSH_PORT, username='******', pkey=None, password=None, connect_timeout=10): if pkey is None and password is None: raise Exception( 'public key and password must have one is not None') self.client = None self.arguments = { 'hostname': hostname, 'port': port, 'username': username, 'password': password, 'pkey': RSAKey.from_private_key(StringIO(pkey)) if isinstance(pkey, str) else pkey, 'timeout': connect_timeout, } @staticmethod def generate_key(): key_obj = StringIO() key = RSAKey.generate(2048) key.write_private_key(key_obj) return key_obj.getvalue(), 'ssh-rsa ' + key.get_base64() def add_public_key(self, public_key): command = f'mkdir -p -m 700 ~/.ssh && \ echo {public_key!r} >> ~/.ssh/authorized_keys && \ chmod 600 ~/.ssh/authorized_keys' code, out = self.exec_command(command) if code != 0: raise Exception(out) def ping(self): with self: return True def get_client(self): if self.client is not None: return self.client self.client = SSHClient() self.client.set_missing_host_key_policy(AutoAddPolicy) self.client.connect(**self.arguments) return self.client def put_file(self, local_path, remote_path): with self as cli: sftp = cli.open_sftp() sftp.put(local_path, remote_path) sftp.close() sftp.open() def put_content_to_remote(self, remote_path, content, mkdir=False): """ 将文本传输到远程服务器 :param remote_path 远程路径 :param content 文件内容 :param mkdir 如果目录不存在, 是否创建相关目录 """ if mkdir: import os bash_dir = os.path.split(remote_path) if len(bash_dir) > 1 and bash_dir[0] != '': self.exec_command(f'mkdir -p {bash_dir[0]}') with self as cli: sftp = cli.open_sftp() with sftp.open(remote_path, 'wb', 1024) as f: f.write(content) def exec_command(self, command, timeout=1800, environment=None): command = 'set -e\n' + command with self as cli: chan = cli.get_transport().open_session() chan.settimeout(timeout) chan.set_combine_stderr(True) if environment: str_env = ' '.join(f"{k}='{v}'" for k, v in environment.items()) command = f'export {str_env} && {command}' chan.exec_command(command) out = chan.makefile("r", -1) return chan.recv_exit_status(), out.read() def exec_command_with_stream(self, command, timeout=1800, environment=None): command = 'set -e\n' + command with self as cli: chan = cli.get_transport().open_session() chan.settimeout(timeout) chan.set_combine_stderr(True) if environment: str_env = ' '.join(f"{k}='{v}'" for k, v in environment.items()) command = f'export {str_env} && {command}' chan.exec_command(command) stdout = chan.makefile("r", -1) out = stdout.readline() while out: yield chan.exit_status, out out = stdout.readline() yield chan.recv_exit_status(), out def __enter__(self): if self.client is not None: raise RuntimeError('Already connected') return self.get_client() def __exit__(self, exc_type, exc_val, exc_tb): self.client.close() self.client = None
ver que um objeto do SSHClient foi criado e qual posição na memória ele está armazenado. Modificado em 14 de março de 2017 por Vitor Mazuco ([email protected]) Editado em 28 Setembro 2018 por Rafael Baena Neto ([email protected]) Alteração para PEP 8 e Python 3 """ from paramiko.client import SSHClient client = SSHClient() print(client)
def fromPrivateKey(host,port=22,username=None,password=None,private_key=None): """deprecated see connect_v2 """ #ssh -i /path/to//private_key user@localhost -p 2222 #ssh -i /path/to//private_key username@host -p port if SSHClient is None: raise Exception("Paramiko not installed") src = SSHClientSource() print(host,port,username,password,private_key) pkey = None if private_key: # non-null, non-empty passphrase = "" # TODO: support passphrases pkey=paramiko.RSAKey.from_private_key_file(\ private_key,passphrase) client = SSHClient() client.load_system_host_keys() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) print("\n---\nConnect With: host=%s:%s user=%s privatekey=`%s`\n"%(\ host,port,username,private_key)) try: if pkey: client.connect(host,port=port, username=username, pkey=pkey,timeout=1.0,compress=True) else: client.connect(host,port=port, username=username,password=password, timeout=1.0,compress=True) except BadHostKeyException as e: sys.stderr.write("got: %s\n"%e.key.asbytes()); sys.stderr.write("expected: %s\n"%e.expected_key.asbytes()); msg = "Connection error on %s:%s using privatekey=%s\n"%(\ host,port,private_key) msg += "you may need to clear ~/.ssh/known_hosts "+\ "for entries related to %s:%s\n"%(host,port); sys.stderr.write(msg); raise Exception(msg); src.client = client src.ftp = client.open_sftp() src.host=host src.port=port return src
def __close_ssh_client(client: SSHClient) -> None: client.close()
class _SSHConnection: """ Helper class handling SFTP communication. If provided with a hostname, automatically initiates the SFTP session. :param hostname: The SSH host, defaults to :const:`None`. :type hostname: str, optional :param port: The port where the SSH host is listening, defaults to :const:`None`. :type port: int, optional :param username: The username on the target SSH host, defaults to :const:`None`. :type username: str, optional :ivar client: The SSH session handler. :vartype client: paramiko.client.SSHClient :ivar sftp_session: The SFTP session handler. :vartype sftp_session: paramiko.sftp_client.SFTPClient """ client = None sftp_session = None def __init__(self, hostname: str = None, port: int = None, username: str = None): """Initialize object.""" if hostname: self.set_session(hostname, port, username) def set_session(self, hostname: str, port: int = None, username: str = None): """ Set up a SFTP session. :param str hostname: The SSH host. :param port: The port where the SSH host is listening, defaults to :const:`None`. :type port: int, optional :param username: The username on the target SSH host, defaults to :const:`None`. :type username: str, optional """ self.client = SSHClient() self.client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) if port and username: self.client.connect(hostname, port, username) elif port: self.client.connect(hostname, port) elif username: self.client.connect(hostname, username=username) else: self.client.connect(hostname) self.sftp_session = self.client.open_sftp() def close_session(self): """Close the SFTP session.""" if self.is_active(): self.client.close() def mkdir_p(self, path: str): """ Simulate the :command:`mkdir -p <path>` Unix command. It creates the directory and all its non-existing parents. :param str path: The path to a directory. """ dirs = [] while len(path) > 1: dirs.append(path) path = os.path.dirname(path) if len(path) == 1 and not path.startswith("/"): dirs.append(path) while dirs: path = dirs.pop() try: self.sftp_session.stat(path) except IOError: self.sftp_session.mkdir(path, mode=0o755) # def write_file(self, content: str, path: str): # """ # Create or overwrite a file under `path` and store `content` in it. # # It creates the parent directories if required. # # :param str content: The file content. # :param str path: Path to the new file. # """ # self.mkdir_p(os.path.normpath(os.path.dirname(path))) # # with self.sftp_session.open(path, "w") as sftp_file: # sftp_file.write(content) def put_file(self, local_path, remote_path): """ Copy the local file at `local_path` into `remote_path`. It creates the parent directories if required. :param str local_path: Path to the local file. :param str remote_path: Path to the remote file. """ self.mkdir_p(os.path.normpath(os.path.dirname(remote_path))) self.sftp_session.put(local_path, remote_path) def is_active(self) -> bool: """Check whether the SSH session is active or not. :return: `True` if the SSH session is active, `False` otherwise. :rtype: bool """ if self.client: transport = self.client.get_transport() if transport is not None and transport.is_active(): try: transport.send_ignore() return True except EOFError: return False return False
#!usr/bin/python # -*- coding: utf-8 -*- """ Created on Wed Apr 5 22:05:25 2017 @author: Everton """ from paramiko.client import SSHClient import paramiko client = SSHClient() client.load_system_host_keys() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) print client host = '192.168.202.1' user = '******' password = '******' client.connect(hostname=host, username=user, password=password) stdin, stdout, stderr = client.exec_command('/sbin/ifconfig') if stderr.channel.recv_exit_status() != 0: print stderr.channel.recv_exit_status() print stderr.read() else: print stdout.read()
class BaseSSHWrapper(BaseAutoscalingClass): """ A base class, which can connect via SSH to a machine.""" def __init__(self, readableName, address, pemFile=None, password=None, userName="******", timeout=600): """ Constr. @param readableName: A readale description of the machine. Must not be None. @param address: The address of the machine. Must not be None. @param pemFile: The pem file for SSH authentication. @param password: The password for SSH authentication. @param userName: The userName for SSH authentication. Must not be None. @param timeout: The SSH connection timeout. Must not be None. Must be positive. """ super(BaseSSHWrapper, self).__init__(readableName=readableName) assert address is not None, "Address is None" assert userName is not None, "User name is None" assert timeout is not None, "Timeout is None" assert timeout > 0, "Timeout is not positive: " + str(timeout) assert pemFile is None or os.path.isfile( pemFile), "File \"%s\" does not exist" % (pemFile) self.address = address self.password = password self.pemFile = pemFile self.userName = userName self.timeout = timeout log.info("Creating entity \"%s\" at %s", self.readableName, self.address) self.initSSHClient() def initSSHClient(self): """ Tries to establish connection with the host. @raise SSHException: if the connection could not be established. """ self.client = None waitPeriod = 10 attempts = 10 # Try to connect but not more than attempts times for iteration in range(attempts): # If not the first time - sleep a bit. Do not bombard the server with requests if iteration > 0: time.sleep(waitPeriod) # Try establishing ssh client try: self.client = SSHClient() self.client.set_missing_host_key_policy( paramiko.AutoAddPolicy()) if self.pemFile is not None: self.client.connect(self.address, username=self.userName, key_filename=self.pemFile, timeout=self.timeout) else: self.client.connect(self.address, username=self.userName, password=self.password, timeout=self.timeout) break except (SSHException, socket.error) as e: self.client = None log.error("Could not connect to host %s err: %s", self.readableName, str(e)) # If we could not connect several times - throw an exception if self.client == None: raise SSHException('Could not connect ' + str(attempts) + ' times in a row') def getSSHClient(self): """ Retrieves an SSH connection to the machine. @return a connection @raise SSHException: if the connection could not be established. """ if self.client == None: log.warning("SSH connection to %s will be recreated", self.address) self.initSSHClient() return self.client def execRemoteCommand(self, command, asynch=False, recoverFromFailure=True): """ Executes the command on the remove machine. @param command: The command to execute on the remote host. Must not be None. @param asynch: A boolean flag, whether to run the command asynchrounously or not. @param recoverFromFailure: A boolean flag, whether to try to recover if the connection had staled or failed. @return the output of the command (a list of text lines), if it was run synchrounously. @raise SSHException: if a connection could not be established, or the command gave an error. """ assert command is not None, "Command is None" assert asynch is not None, "Asynch is None" assert recoverFromFailure is not None, "recoverFromFailure is None" try: _, stdout, stderr = self.getSSHClient().exec_command(command) output = [] if not asynch: output = stdout.readlines() errors = stderr.readlines() if errors: log.warning( "Error messages encountered when connecting to %s, messages: %s", self.address, formatOutput(errors)) return output except (SSHException, socket.error) as e: if recoverFromFailure: # Mark the connection for re-instantiation and try again self.client = None return self.execRemoteCommand(command, asynch, False) else: raise e def close(self): """ Closes the underlying connection. @raise SSHException: if a connection could not be closed. """ if self.client != None: self.client.close() self.client = None def __del__(self): self.close()
class SystemVM(object): def __init__(self, host='default', vagrantDir=None, controlVagrant=True): global _defaultVagrantDir self.host = host self._controlVagrant = controlVagrant if vagrantDir is None: vagrantDir = _defaultVagrantDir self._vagrant = Vagrant(root=vagrantDir) self._startedVagrant = False self._sshClient = None self._sshConfigStr = None self._sshConfig = None self._sshHostConfig = None def maybeUp(self): if not self._controlVagrant: return state = self._vagrant.status(vm_name=self.host)[0].state if state == Vagrant.NOT_CREATED: self._vagrant.up(vm_name=self.host) self._startedVagrant = True elif state in [Vagrant.POWEROFF, Vagrant.SAVED, Vagrant.ABORTED]: raise Exception( "SystemVM testing does not support resume(), do not use vagrant suspend/halt" ) elif state == Vagrant.RUNNING: self._startedVagrant = False else: raise Exception("Unrecognized vagrant state %s" % state) def maybeDestroy(self): if not self._controlVagrant or not self._startedVagrant: return self._vagrant.destroy(vm_name=self.host) if self._sshClient is not None: self._sshClient.close() def loadSshConfig(self): if self._sshConfig is None: self._sshConfigStr = self._vagrant.ssh_config(vm_name=self.host) configObj = StringIO(self._sshConfigStr) self._sshConfig = SSHConfig() # noinspection PyTypeChecker self._sshConfig.parse(configObj) self._sshHostConfig = self._sshConfig.lookup(self.host) @property def sshConfig(self): if self._sshConfig is None: self.loadSshConfig() return self._sshConfig @property def sshConfigStr(self): if self._sshConfigStr is None: self.loadSshConfig() return self._sshConfigStr @property def sshClient(self): if self._sshClient is None: self.loadSshConfig() self._sshClient = SSHClient() self._sshClient.set_missing_host_key_policy(AutoAddPolicy()) self._sshClient.connect(self.hostname, self.sshPort, self.sshUser, key_filename=self.sshKey, timeout=10) return self._sshClient @property def hostname(self): return self._sshHostConfig.get('hostname', self.host) @property def sshPort(self): return int(self._sshHostConfig.get('port', 22)) @property def sshUser(self): return self._sshHostConfig.get('user', 'root') @property def sshKey(self): return self._sshHostConfig.get('identityfile', '~/.ssh/id_rsa')
class RemoteClient(object): """Remote Client is a wrapper over SSHClient with utility functions. Args: host (string): The hostname of the server to connect. It can be an IP address of the server also. user (string, optional): The user to connect to the remote server. It defaults to root Attributes: host (string): The hostname passed in as a the argument user (string): The user to connect as to the remote server client (:class:`paramiko.client.SSHClient`): The SSHClient object used for all the communications with the remote server. sftpclient (:class:`paramiko.sftp_client.SFTPClient`): The SFTP object for all the file transfer operations over the SSH. """ def __init__(self, host, ip=None, user='******'): self.host = host self.ip = ip self.user = user self.client = SSHClient() self.sftpclient = None self.client.set_missing_host_key_policy(AutoAddPolicy()) self.client.load_system_host_keys() logging.debug("RemoteClient created for host: %s", host) def startup(self): """Function that starts SSH connection and makes client available for carrying out the functions. It tries with the hostname, if it fails it tries with the IP address if supplied """ try: logging.debug("Trying to connect to remote server %s", self.host) self.client.connect(self.host, port=22, username=self.user) self.sftpclient = self.client.open_sftp() except (SSHException, socket.error): if self.ip: logging.warning("Connection with hostname failed. Retrying " "with IP") self._try_with_ip() else: logging.error("Connection to %s failed.", self.host) raise ClientNotSetupException('Could not connect to the host.') def _try_with_ip(self): try: logging.debug("Connecting to IP:%s User:%s", self.ip, self.user) self.client.connect(self.ip, port=22, username=self.user) self.sftpclient = self.client.open_sftp() except (SSHException, socket.error): logging.error("Connection with IP (%s) failed.", self.ip) raise ClientNotSetupException('Could not connect to the host.') def download(self, remote, local): """Downloads a file from remote server to the local system. Args: remote (string): location of the file in remote server local (string): path where the file should be saved """ if not self.sftpclient: raise ClientNotSetupException( 'Cannot download file. Client not initialized') try: self.sftpclient.get(remote, local) return "Download successful. File at: {0}".format(local) except OSError: return "Error: Local file %s doesn't exist." % local except IOError: return "Error: Remote location %s doesn't exist." % remote def upload(self, local, remote): """Uploads the file from local location to remote server. Args: local (string): path of the local file to upload remote (string): location on remote server to put the file """ if not self.sftpclient: raise ClientNotSetupException( 'Cannot upload file. Client not initialized') try: self.sftpclient.put(local, remote) return "Upload successful. File at: {0}".format(remote) except OSError: return "Error: Local file %s doesn't exist." % local except IOError: return "Error: Remote location %s doesn't exist." % remote def exists(self, filepath): """Returns whether a file exists or not in the remote server. Args: filepath (string): path to the file to check for existance Returns: True if it exists, False if it doesn't """ if not self.client: raise ClientNotSetupException( 'Cannot run procedure. Client not initialized') cin, cout, cerr = self.client.exec_command('stat {0}'.format(filepath)) if len(cout.read()) > 5: return True elif len(cerr.read()) > 5: return False def run(self, command): """Run a command in the remote server. Args: command (string): the command to be run on the remote server Returns: tuple of three strings containing text from stdin, stdout an stderr """ if not self.client: raise ClientNotSetupException( 'Cannot run procedure. Client not initialized') #buffers = self.client.exec_command(command, timeout=30) buffers = self.client.exec_command(command) output = [] for buf in buffers: try: output.append(buf.read()) except IOError: output.append('') return tuple(output) def get_file(self, filename): """Reads content of filename on remote server Args: filename (string): name of file to be read from remote server Returns: tuple: True/False, file like object / error """ f = StringIO.StringIO() try: r = self.sftpclient.getfo(filename, f) f.seek(0) return r, f except Exception as err: return False, err def put_file(self, filename, filecontent): """Puts content to a file on remote server Args: filename (string): name of file to be written on remote server filecontent (string): content of file Returns: tuple: True/False, file size / error """ f = StringIO.StringIO() f.write(filecontent) f.seek(0) try: r = self.sftpclient.putfo(f, filename) return True, r.st_size except Exception as err: return False, err def mkdir(self, dirname): """Creates a new directory. Args: dirname (string): the full path of the directory that needs to be created Returns: a tuple containing the success or failure of operation and dirname on success and error on failure """ try: self.sftpclient.mkdir(dirname) return True, dirname except Exception as err: return False, err def listdir(self, dirname): """Lists all the files and folders in a directory. Args: dirname (string): the full path of the directory that needs to be listed Returns: a list of the files and folders in the directory """ try: r = self.sftpclient.listdir(dirname) return True, r except Exception as err: return False, err def close(self): """Close the SSH Connection """ self.client.close() def __repr__(self): return "RemoteClient({0}, ip={1}, user={2})".format( self.host, self.ip, self.user)
class USIEngine: def __init__(self, name, host, engine_path, nodes=None, multiPV=1, threads=1, delay=0, delay2=0): self.name = name self.nodes = nodes self.multiPV = multiPV self.quit_event = threading.Event() self.client = SSHClient() self.client.set_missing_host_key_policy(paramiko.client.WarningPolicy) #self.client.load_system_host_keys() keys = self.client.get_host_keys() keys.clear() self.client.connect(host) dirname = os.path.dirname(engine_path) command = f'cd {dirname} && {engine_path}' self.stdin, self.stdout, self.stderr = \ self.client.exec_command(command, bufsize=0) self.queue = queue.Queue() self.watcher_thread = threading.Thread(target=self.stream_watcher, name='engine_watcher', args=(self.stdout, )) self.watcher_thread.start() self.pvs = [[]] * multiPV self.status = 'wait' self.position = 'startpos' self.send('usi') self.wait_for('usiok') self.set_option('Threads', threads) self.set_option('USI_Ponder', 'false') self.set_option('NetworkDelay', delay) self.set_option('NetworkDelay2', delay2) self.set_option('MultiPV', multiPV) if nodes: self.set_option('NodesLimit', nodes) #self.send('isready') #self.wait_for('readyok') def stream_watcher(self, stream): # for line in iter(stream.readline, b''): prog = re.compile('.*score cp (-?\d+) (?:multipv (\d+))? .*pv (.+)$') #for line in iter(stream.readline, b''): while (not self.quit_event.isSet()) and (not stream.closed): line = stream.readline().strip() if len(line): logging.debug(f'{self.name} > {line}') print(f'info string {self.name} > {line}', flush=True) match = prog.match(line) if match: logging.debug(f'match: {match.group(1, 2, 3)}') if match.group(2): # multi PV num = int(match.group(2)) - 1 else: # single PV num = 0 logging.debug(f'{self.name}: Found score of pv {num}') self.pvs[num] = [int(match.group(1)), match.group(3)] # bestmove if line.startswith('bestmove'): self.status = 'wait' self.queue.put(line) logging.debug(f'{self.name}: terminating the engine watcher thread') def set_option(self, name, value): self.send(f'setoption name {name} value {value}') def __del__(self): pass #self.terminate() def terminate(self): self.stop() self.quit_event.set() self.send('usi') self.watcher_thread.join(1) self.send('quit') self.status = 'quit' #self.client.close() def send(self, command): logging.debug(f'sending {command} to {self.name}') print(f'info string sending {command} to {self.name}', flush=True) self.stdin.write((command + '\n').encode('utf-8')) self.stdin.flush() def wait_for(self, command): logging.debug(f'{self.name}: waiting for {command}') lines = "" while self.client.get_transport().is_active(): line = self.queue.get() lines += f'{line}\n' if (line == command): logging.debug(f'{self.name}: found {command}') self.status = 'wait' return lines def wait_for_bestmove(self): logging.debug(f'{self.name}: waiting for bestmove...') infostr(f'{self.name}: waiting for bestmove...') while self.client.get_transport().is_active(): line = self.queue.get() if (line.startswith('bestmove')): logging.debug(f'{self.name}: found bestmove') infostr(f'{self.name}: found bestmove') bestmove = line[9:].split()[0].strip() self.status = 'wait' return bestmove def set_position(self, pos): self.position = pos self.send(f'position {pos}') def clear_queue(self): while True: try: line = self.queue.get_nowait() print(f'info string {self.name}: clearing queue: {line}', flush=True) except queue.Empty: break def ponder(self, command): infostr(f'{self.name}: in ponder()') self.go_command = command if 'ponder' not in command: command = command.replace('go', 'go ponder') self.send(command) self.status = 'ponder' infostr(f'{self.name}: end of ponder()') def stop(self): infostr(f'{self.name}: in stop()') if self.status in ['go', 'ponder']: self.send('stop') self.wait_for_bestmove() self.status = 'wait'
def run_browser_tests(self): common_options = [ 'phantomjs', '--debug=true', '--ignore-ssl-errors=true', '--local-url-access=false', '--local-storage-path=/dev/null', '--offline-storage-path=/dev/null', '/dev/stdin', ] browser_command = ' '.join(common_options + [shlex.quote(self.idna_url)]) # Read the private key private_key = RSAKey.from_private_key_file(settings.SSH_PRIVATE_KEY) # Do the v4-only, v6-only and the NAT64 request in parallel v4only_client = SSHClient() v4only_client.load_host_keys(settings.SSH_KNOWN_HOSTS) v4only_client.connect(settings.V4_HOST, username=settings.SSH_USERNAME, pkey=private_key, allow_agent=False, look_for_keys=False) logger.debug("Running '{}' on {}".format(browser_command, settings.V4_HOST)) v4only_stdin, v4only_stdout, v4only_stderr = v4only_client.exec_command( browser_command, timeout=120) if self.ipv6_dns_results: v6only_client = SSHClient() v6only_client.load_host_keys(settings.SSH_KNOWN_HOSTS) v6only_client.connect(settings.V6_HOST, username=settings.SSH_USERNAME, pkey=private_key, allow_agent=False, look_for_keys=False) logger.debug("Running '{}' on {}".format(browser_command, settings.V4_HOST)) v6only_stdin, v6only_stdout, v6only_stderr = v6only_client.exec_command( browser_command, timeout=120) else: v6only_client = v6only_stdin = v6only_stdout = v6only_stderr = None nat64_client = SSHClient() nat64_client.load_host_keys(settings.SSH_KNOWN_HOSTS) nat64_client.connect(settings.NAT64_HOST, username=settings.SSH_USERNAME, pkey=private_key, allow_agent=False, look_for_keys=False) logger.debug("Running '{}' on {}".format(browser_command, settings.V4_HOST)) nat64_stdin, nat64_stdout, nat64_stderr = nat64_client.exec_command( browser_command, timeout=120) # Placeholders v4only_img = None v4only_img_bytes = None v6only_img = None v6only_img_bytes = None nat64_img = None nat64_img_bytes = None self.v4only_data = {} self.v6only_data = {} self.nat64_data = {} # Push the test script to the workers script_filename = os.path.realpath( os.path.join(os.path.dirname(__file__), 'render_page.js')) script = open(script_filename, 'rb').read() v4only_stdin.write(script) v4only_stdin.close() v4only_stdin.channel.shutdown_write() if v6only_client: v6only_stdin.write(script) v6only_stdin.close() v6only_stdin.channel.shutdown_write() nat64_stdin.write(script) nat64_stdin.close() nat64_stdin.channel.shutdown_write() # Wait for tests to finish try: logger.debug("Receiving data from IPv4-only test") v4only_json = v4only_stdout.read() v4only_debug = v4only_stderr.read() v4only_exit = v4only_stdout.channel.recv_exit_status() self.v4only_data = json.loads( v4only_json.decode('utf-8'), object_pairs_hook=OrderedDict) if v4only_json else {} self.v4only_debug = v4only_debug.decode('utf-8') self.v4only_data['exit_code'] = v4only_exit if 'image' in self.v4only_data: if self.v4only_data['image']: v4only_img_bytes = base64.decodebytes( self.v4only_data['image'].encode('ascii')) # noinspection PyTypeChecker v4only_img = skimage.io.imread( io.BytesIO(v4only_img_bytes)) del self.v4only_data['image'] except socket.timeout: logger.error("{}: IPv4-only load timed out".format(self.url)) if v6only_client: try: logger.debug("Receiving data from IPv6-only test") v6only_json = v6only_stdout.read() v6only_debug = v6only_stderr.read() v6only_exit = v6only_stdout.channel.recv_exit_status() self.v6only_data = json.loads( v6only_json.decode('utf-8'), object_pairs_hook=OrderedDict) if v6only_json else {} self.v6only_debug = v6only_debug.decode('utf-8') self.v6only_data['exit_code'] = v6only_exit if 'image' in self.v6only_data: if self.v6only_data['image']: v6only_img_bytes = base64.decodebytes( self.v6only_data['image'].encode('ascii')) # noinspection PyTypeChecker v6only_img = skimage.io.imread( io.BytesIO(v6only_img_bytes)) del self.v6only_data['image'] except socket.timeout: logger.error("{}: IPv6-only load timed out".format(self.url)) else: logger.info("{}: Not running IPv6-only test".format(self.url)) try: logger.debug("Receiving data from NAT64 test") nat64_json = nat64_stdout.read() nat64_debug = nat64_stderr.read() nat64_exit = nat64_stdout.channel.recv_exit_status() self.nat64_data = json.loads( nat64_json.decode('utf-8'), object_pairs_hook=OrderedDict) if nat64_json else {} self.nat64_debug = nat64_debug.decode('utf-8') self.nat64_data['exit_code'] = nat64_exit if 'image' in self.nat64_data: if self.nat64_data['image']: nat64_img_bytes = base64.decodebytes( self.nat64_data['image'].encode('ascii')) # noinspection PyTypeChecker nat64_img = skimage.io.imread(io.BytesIO(nat64_img_bytes)) del self.nat64_data['image'] except socket.timeout: logger.error("{}: NAT64 load timed out".format(self.url)) # Done talking to workers, close connections if v4only_client: v4only_client.close() if v6only_client: v6only_client.close() if nat64_client: nat64_client.close() # Calculate score based on resources v4only_resources_ok = self.v4only_resources[0] if v4only_resources_ok > 0: self.v6only_resource_score = min( self.v6only_resources[0] / v4only_resources_ok, 1) logger.info("{}: IPv6-only Resource Score = {:0.2f}".format( self.url, self.v6only_resource_score)) self.nat64_resource_score = min( self.nat64_resources[0] / v4only_resources_ok, 1) logger.info("{}: NAT64 Resource Score = {:0.2f}".format( self.url, self.nat64_resource_score)) else: logger.error( "{}: did not load over IPv4-only, unable to perform resource test" .format(self.url)) return_value = 0 if v4only_img_bytes: # Store the image self.v4only_image.save('v4.png', ContentFile(v4only_img_bytes), save=False) else: return_value |= 1 if v6only_img_bytes: # Store the image self.v6only_image.save('v6.png', ContentFile(v6only_img_bytes), save=False) else: return_value |= 2 if nat64_img_bytes: # Store the image self.nat64_image.save('nat64.png', ContentFile(nat64_img_bytes), save=False) else: return_value |= 4 if v4only_img is not None: logger.debug("{}: Loading IPv4-only screenshot".format(self.url)) if v6only_img is not None: logger.debug("{}: Loading IPv6-only screenshot".format( self.url)) # Suppress stupid warnings with warnings.catch_warnings(record=True): self.v6only_image_score = compare_ssim(v4only_img, v6only_img, multichannel=True) logger.info("{}: IPv6-only Image Score = {:0.2f}".format( self.url, self.v6only_image_score)) else: logger.warning( "{}: did not load over IPv6-only, 0 score".format( self.url)) self.v6only_image_score = 0.0 if nat64_img is not None: logger.debug("{}: Loading NAT64 screenshot".format(self.url)) # Suppress stupid warnings with warnings.catch_warnings(record=True): self.nat64_image_score = compare_ssim(v4only_img, nat64_img, multichannel=True) logger.info("{}: NAT64 Image Score = {:0.2f}".format( self.url, self.nat64_image_score)) else: logger.warning("{}: did not load over NAT64, 0 score".format( self.url)) self.nat64_image_score = 0.0 else: logger.error( "{}: did not load over IPv4-only, unable to perform image test" .format(self.url)) self.save() return return_value
def ssh_paramiko_connect_to(display_desc): #plain socket attributes: dtype = display_desc["type"] host = display_desc["host"] port = display_desc.get("ssh-port", 22) #ssh and command attributes: username = display_desc.get("username") or get_username() if "proxy_host" in display_desc: display_desc.setdefault("proxy_username", get_username()) password = display_desc.get("password") remote_xpra = display_desc["remote_xpra"] proxy_command = display_desc["proxy_command"] #ie: "_proxy_start" socket_dir = display_desc.get("socket_dir") display = display_desc.get("display") display_as_args = display_desc["display_as_args"] #ie: "--start=xterm :10" paramiko_config = display_desc.copy() paramiko_config.update(display_desc.get("paramiko-config", {})) socket_info = { "host": host, "port": port, } def get_keyfiles(host_config, config_name="key"): keyfiles = (host_config or {}).get("identityfile") or get_default_keyfiles() keyfile = paramiko_config.get(config_name) if keyfile: keyfiles.insert(0, keyfile) return keyfiles with nogssapi_context(): from paramiko import SSHConfig, ProxyCommand ssh_config = SSHConfig() user_config_file = os.path.expanduser("~/.ssh/config") sock = None host_config = None if os.path.exists(user_config_file): with open(user_config_file) as f: ssh_config.parse(f) log("parsed user config '%s'", user_config_file) try: log("%i hosts found", len(ssh_config.get_hostnames())) except KeyError: pass host_config = ssh_config.lookup(host) if host_config: log("got host config for '%s': %s", host, host_config) chost = host_config.get("hostname", host) cusername = host_config.get("user", username) cport = host_config.get("port", port) try: port = int(cport) except (TypeError, ValueError): raise InitExit(EXIT_SSH_FAILURE, "invalid ssh port specified: '%s'" % cport) from None proxycommand = host_config.get("proxycommand") if proxycommand: log("found proxycommand='%s' for host '%s'", proxycommand, chost) sock = ProxyCommand(proxycommand) log("ProxyCommand(%s)=%s", proxycommand, sock) from xpra.child_reaper import getChildReaper cmd = getattr(sock, "cmd", []) def proxycommand_ended(proc): log("proxycommand_ended(%s) exit code=%s", proc, proc.poll()) getChildReaper().add_process(sock.process, "paramiko-ssh-client", cmd, True, True, callback=proxycommand_ended) proxy_keys = get_keyfiles(host_config, "proxy_key") log("proxy keys=%s", proxy_keys) from paramiko.client import SSHClient ssh_client = SSHClient() ssh_client.load_system_host_keys() log("ssh proxy command connect to %s", (chost, cport, sock)) ssh_client.connect(chost, cport, sock=sock) transport = ssh_client.get_transport() do_ssh_paramiko_connect_to( transport, chost, cusername, password, host_config or ssh_config.lookup("*"), proxy_keys, paramiko_config) chan = paramiko_run_remote_xpra(transport, proxy_command, remote_xpra, socket_dir, display_as_args) peername = (chost, cport) conn = SSHProxyCommandConnection(chan, peername, peername, socket_info) conn.target = host_target_string("ssh", cusername, chost, port, display) conn.timeout = SOCKET_TIMEOUT conn.start_stderr_reader() conn.process = (sock.process, "ssh", cmd) from xpra.net import bytestreams from paramiko.ssh_exception import ProxyCommandFailure bytestreams.CLOSED_EXCEPTIONS = tuple( list(bytestreams.CLOSED_EXCEPTIONS) + [ProxyCommandFailure]) return conn keys = get_keyfiles(host_config) from xpra.scripts.main import socket_connect from paramiko.transport import Transport from paramiko import SSHException if "proxy_host" in display_desc: proxy_host = display_desc["proxy_host"] proxy_port = display_desc.get("proxy_port", 22) proxy_username = display_desc.get("proxy_username", username) proxy_password = display_desc.get("proxy_password", password) proxy_keys = get_keyfiles(host_config, "proxy_key") sock = socket_connect(dtype, proxy_host, proxy_port) middle_transport = Transport(sock) middle_transport.use_compression(False) try: middle_transport.start_client() except SSHException as e: log("start_client()", exc_info=True) raise InitExit(EXIT_SSH_FAILURE, "SSH negotiation failed: %s" % e) from None proxy_host_config = ssh_config.lookup(host) do_ssh_paramiko_connect_to( middle_transport, proxy_host, proxy_username, proxy_password, proxy_host_config or ssh_config.lookup("*"), proxy_keys, paramiko_config) log("Opening proxy channel") chan_to_middle = middle_transport.open_channel( "direct-tcpip", (host, port), ('localhost', 0)) transport = Transport(chan_to_middle) transport.use_compression(False) try: transport.start_client() except SSHException as e: log("start_client()", exc_info=True) raise InitExit(EXIT_SSH_FAILURE, "SSH negotiation failed: %s" % e) from None do_ssh_paramiko_connect_to(transport, host, username, password, host_config or ssh_config.lookup("*"), keys, paramiko_config) chan = paramiko_run_remote_xpra(transport, proxy_command, remote_xpra, socket_dir, display_as_args) peername = (host, port) conn = SSHProxyCommandConnection(chan, peername, peername, socket_info) conn.target = "%s via %s" % ( host_target_string("ssh", username, host, port, display), host_target_string("ssh", proxy_username, proxy_host, proxy_port, None), ) conn.timeout = SOCKET_TIMEOUT conn.start_stderr_reader() return conn #plain TCP connection to the server, #we open it then give the socket to paramiko: sock = socket_connect(dtype, host, port) sockname = sock.getsockname() peername = sock.getpeername() log("paramiko socket_connect: sockname=%s, peername=%s", sockname, peername) transport = Transport(sock) transport.use_compression(False) try: transport.start_client() except SSHException as e: log("start_client()", exc_info=True) raise InitExit(EXIT_SSH_FAILURE, "SSH negotiation failed: %s" % e) from None do_ssh_paramiko_connect_to(transport, host, username, password, host_config or ssh_config.lookup("*"), keys, paramiko_config) chan = paramiko_run_remote_xpra(transport, proxy_command, remote_xpra, socket_dir, display_as_args) conn = SSHSocketConnection(chan, sock, sockname, peername, (host, port), socket_info) conn.target = host_target_string("ssh", username, host, port, display) conn.timeout = SOCKET_TIMEOUT conn.start_stderr_reader() return conn
def set_client(ip, port, numb_conn, Tunnel, hostname=None, username=None, Key_path=None, passphrase=None): """ this method is responsible for establishing a connection to a server (Ip and port of the server needed to be specified) In a direct LAN enviroment if Tunnel was Fale (hostname,username,keypath,passphrase) aren't needed; connection thought SSH tunneling if tunnel was True Hostname and username needed to be specified keypath and pass phrase needed to be specified if there isn't an ssh agent otherwise it isn't needed. """ client = [] transport = None if Tunnel: server_address = (ip, port) sshclient = SSHClient() sshclient.load_system_host_keys() sshclient.set_missing_host_key_policy(AutoAddPolicy()) try: sshclient.connect(hostname=hostname, username=username, passphrase=passphrase, key_filename=Key_path) transport = sshclient.get_transport() except (BadHostKeyException, SSHException, AuthenticationException) as e: print("A problem trying to connection to the Host {}".format( hostname)) raise e transport.close() return None, None try: for i in range(numb_conn): client.append( transport.open_channel(kind='direct-tcpip', src_addr=server_address, dest_addr=server_address)) except SSHException as e: print( "problem Has been faced trying to make direct-tcpip conneciton" ) raise e for i in client: i.close() sshclient.get_transport().close() raise (KeyboardInterrupt) except (KeyboardInterrupt): for i in client: i.close() sshclient.get_transport().close() return None, None else: server_address = (ip, port) try: for i in range(numb_conn): client.append(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) client[i].connect(server_address) except (OSError): print("The connection #{} failed".format(i + 1)) print("The process is stopping") raise (KeyboardInterrupt) except (KeyboardInterrupt): for i in client: i.close() return None, None return client, transport #returning the connection object for further use
from paramiko.client import SSHClient from paramiko import SSHConfig SSH_CONFIG = "<insert path to ssh config>" SSH_HOST = "example" config = SSHConfig() config_file = open(SSH_CONFIG) config.parse(config_file) dev_config = config.lookup(SSH_HOST) client = SSHClient() client.load_system_host_keys() HOST = dev_config['hostname'] client.connect(HOST, port=int(dev_config['port']), username=dev_config['user'], password=dev_config['password']) client.close()