def __init__(self, host, user=None, password=None, port=None, key=None, connect_max_retries=2): ssh_config = paramiko.SSHConfig() _ssh_config_file = os.path.sep.join( [os.path.expanduser('~'), '.ssh', 'config']) if os.path.exists(_ssh_config_file): ssh_config.parse(open(_ssh_config_file)) host_config = ssh_config.lookup(host) resolved_address = (host_config['hostname'] if 'hostname' in host_config else host) _user = host_config['user'] if 'user' in host_config else None if user: user = user else: user = _user client = paramiko.SSHClient() client.set_missing_host_key_policy(paramiko.MissingHostKeyPolicy()) self.client = client self.channel = None self.user = user self.password = password self.key = key self.port = port if port else 22 self.host = resolved_address self._max_retries = 2 self._connect_to_host() self.running = False
def _create_channel(self, timeout=10.0): """ Create a secure tunnel across an SSH Transport. """ client = paramiko.SSHClient() client.set_missing_host_key_policy(paramiko.MissingHostKeyPolicy()) try: connection = client.connect(self._ssh_to, username=self._login, \ password=self._passwd, banner_timeout=2.0) except Exception as e: cprint.colorPrint( 'Could not do SSH connect to %s. Error: %s' % (self._ssh_to, e), 'r') #raise Exception("ERROR") try: self._channel = client.invoke_shell() self._channel.settimeout(timeout) # To avoid gc of SSHClient object associated with the channel self._channel.keep_this = client except SSHException as e: cprint.colorPrint( 'Could not open SSH channel on %s. Error: %s' % (self._ssh_to, e), 'r') #raise Exception("ERROR") self._channel_fd = self._channel.fileno()
def ssh_client(ip, user, private_key_filepath=None, password=None, proxy_settings=None): """ Retrieves and attemts an SSH connection :param ip: the IP of the host to connect :param user: the user with which to connect :param private_key_filepath: when None, password is required :param password: when None, private_key_filepath is required :param proxy_settings: instance of os_credentials.ProxySettings class (optional) :return: the SSH client if can connect else false """ logger.debug('Retrieving SSH client') ssh = paramiko.SSHClient() ssh.set_missing_host_key_policy(paramiko.MissingHostKeyPolicy()) try: proxy_cmd = None if proxy_settings and proxy_settings.ssh_proxy_cmd: proxy_cmd_str = str(proxy_settings.ssh_proxy_cmd.replace('%h', ip)) proxy_cmd_str = proxy_cmd_str.replace("%p", '22') proxy_cmd = paramiko.ProxyCommand(proxy_cmd_str) pk_abs_path = None if not password and private_key_filepath: pk_abs_path = os.path.expanduser(private_key_filepath) ssh.connect( ip, username=user, key_filename=pk_abs_path, password=password, sock=proxy_cmd) logger.info('Obtained SSH connection to %s', ip) return ssh except Exception as e: logger.debug('Unable to connect via SSH with message - ' + str(e))
def _connect_tunnel(self, host, **paramiko_kwargs): """Connects to SSH server via an intermediate SSH tunnel server. client (me) -> tunnel (ssh server to proxy through) -> ``self.host`` (ssh server to run command) :rtype: :py:class:`paramiko.SSHClient` Client to remote SSH destination via intermediate SSH tunnel server. """ self.proxy_client = paramiko.SSHClient() self.proxy_client.set_missing_host_key_policy( paramiko.MissingHostKeyPolicy()) self._connect(self.proxy_client, self.proxy_host, self.proxy_port, user=self.proxy_user, password=self.proxy_password, pkey=self.proxy_pkey, **paramiko_kwargs) logger.info("Connecting via SSH proxy %s:%s -> %s:%s", self.proxy_host, self.proxy_port, host, self.port,) try: proxy_channel = self.proxy_client.get_transport().open_channel( 'direct-tcpip', (host, self.port,), ('127.0.0.1', 0), timeout=self.timeout) sleep(0) return self._connect(self.client, host, self.port, sock=proxy_channel, **paramiko_kwargs) except (ChannelException, paramiko.SSHException) as ex: error_type = ex.args[1] if len(ex.args) > 1 else ex.args[0] raise ConnectionErrorException( "Error connecting to host '%s:%s' - %s", host, self.port, str(error_type))
def upload_binary_to_client(hostname, port, username, password, file_src_path, binary_path, id_file): try: t = paramiko.Transport((hostname, port)) pkey = None if id_file: pkey = paramiko.RSAKey.from_private_key_file(id_file) t.connect(username=username, pkey=pkey) else: t.connect(username=username, password=password) sftp = paramiko.SFTPClient.from_transport(t) # upload binary sftp.put(file_src_path, binary_path) t.close() client = paramiko.SSHClient() client.load_system_host_keys() client.set_missing_host_key_policy(paramiko.MissingHostKeyPolicy()) client.connect(hostname, port, username, password, pkey) except paramiko.AuthenticationException as e: raise Exception("Authentification error: " + e[0]) except Exception, e: try: t.close() client.close() except: pass raise Exception("Caught exception when uploading binary [" + binary_path + "]: " + str(e))
def __init__( self, config: Config, hostname: str, username: str, key: str = None, ): super().__init__(config=config) ssh_config = paramiko.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) # Thanks https://gist.github.com/acdha/6064215 user_config = ssh_config.lookup(hostname) if 'hostname' in user_config: hostname = user_config['hostname'] if 'user' in user_config: username = user_config['user'] if 'identityfile' in user_config: key = user_config['identityfile'][0] self.client = paramiko.SSHClient() self.client.set_missing_host_key_policy( paramiko.MissingHostKeyPolicy()) self.client.connect( hostname=hostname, username=username, pkey=paramiko.RSAKey.from_private_key_file( key or os.path.expanduser("~/.ssh/id_rsa")), ) self.env: Dict[str, str] = {}
def attempt(Password): IP = "127.0.0.1" USER = "******" PORT = 22 try: ssh = paramiko.SSHClient() ssh.load_system_host_keys() ssh.set_missing_host_key_policy(paramiko.MissingHostKeyPolicy()) try: ssh.connect(IP, port=PORT, username=USER, password=Password) print("Connected successfully. Password = "******"Incorrect password: "******"Most probably this is caused by a missing host key") pass except Exception as error: print("Unknown error: " + error) pass ssh.close() except Exception as error: print(error)
def bruteforce(self): with open(self.passwordfile, 'r') as f: passwords = f.read() pwds = passwords.splitlines() for pwd in pwds: try: ssh_client = paramiko.SSHClient() ssh_client.load_system_host_keys() ssh_client.set_missing_host_key_policy( paramiko.MissingHostKeyPolicy()) try: ssh_client.connect(self.IP, port=self.port, username=self.username, password=pwd) print("Password found: " + pwd) return pwd break except paramiko.AuthenticationException as error: print("Failed Attempt: " + pwd) continue except socket.error as error: print("Socket error: ", error) continue except paramiko.SSHException as error: print("SSHException: ", error) continue except Exception as error: print("Exception: ", error) continue ssh_client.close() except Exception as error: print("OUTSIDE: ", error) return False return False
def run_cmd(self, host, key_file, cmd, expect_status=0): """ run cmd on host via ssh using keyfile. if the result of the command is different than expect_status, raise an exception. """ print "Running \"{0}\" on {1}".format(cmd, host) cmd = cmd.replace('"', '\"') ssh = paramiko.SSHClient() ssh.set_missing_host_key_policy( paramiko.MissingHostKeyPolicy()) # ignore unknown hosts ssh.connect(host, username='******', key_filename=key_file, password='') chan = ssh.get_transport().open_session() chan.exec_command(cmd) stdin = chan.makefile('wb') stdout = chan.makefile('rb') stderr = chan.makefile_stderr('rb') status = chan.recv_exit_status() if status != expect_status: raise Exception( "command failed ({0}) on host {1}: {2}\n{3}".format( status, host, cmd, ''.join(stdout.readlines() + stderr.readlines()))) ssh.close()
def connect(self): try: self._client.set_missing_host_key_policy( paramiko.MissingHostKeyPolicy()) self._client.connect(hostname=self._address, port=self._port, username=self._login, password=self._password, timeout=self._timeout) channel = self._client.invoke_shell() channel.set_combine_stderr(False) channel.settimeout(2) self._shell = self.StandartChannels( stdin=channel.makefile('wb'), stdout=channel.makefile('r'), stderr=channel.makefile_stderr('r')) self.interactive_command('echo test') except paramiko.AuthenticationException: self.logger.debug(f'AuthenticationError {self._login}' f' on {self._address}') raise AuthenticationFailure(login=self._login, password=self._password, address=self._address, port=self._port) except socket.timeout: self.logger.debug(f'Host {self._address} is not available') raise HostNotResponsible(address=self._address, port=self._port) except paramiko.SSHException: self.logger.debug(f'TransportError') raise TransportException(address=self._address, port=self._port)
def _connect_tunnel(self): """Connects to SSH server via an intermediate SSH tunnel server. client (me) -> tunnel (ssh server to proxy through) -> \ destination (ssh server to run command) :rtype: `:mod:paramiko.SSHClient` Client to remote SSH destination via intermediate SSH tunnel server. """ self.proxy_client = paramiko.SSHClient() self.proxy_client.set_missing_host_key_policy( paramiko.MissingHostKeyPolicy()) self._connect(self.proxy_client, self.proxy_host, self.proxy_port) logger.info( "Connecting via SSH proxy %s:%s -> %s:%s", self.proxy_host, self.proxy_port, self.host, self.port, ) try: proxy_channel = self.proxy_client.get_transport().\ open_channel('direct-tcpip', (self.host, self.port,), ('127.0.0.1', 0)) return self._connect(self.client, self.host, self.port, sock=proxy_channel) except channel_exception, ex: error_type = ex.args[1] if len(ex.args) > 1 else ex.args[0] raise ConnectionErrorException( "Error connecting to host '%s:%s' - %s", self.host, self.port, str(error_type))
def handler(context, inputs): salt_master = inputs["customProperties"] ["salt_master"] # ip du salt master username="******" salt_master_password = inputs["customProperties"] ["salt_master_password"] # password de username sur le master # Creation de la commande minion_ID = inputs["resourceNames"][0] +"*" # on rajoute l'etoile pour prendre en compte le hostname ou le FQDN cmd_to_execute="salt-key -y --delete=" +minion_ID #logs print("server salt master : " +salt_master) print("minion ID : " +minion_ID) print("command to execute : " +cmd_to_execute) # execution SSH client = paramiko.SSHClient() client.set_missing_host_key_policy(paramiko.MissingHostKeyPolicy()) # pas de check de clé client.connect(salt_master, username=username, password=salt_master_password) ssh_stdin, ssh_stdout, ssh_stderr = client.exec_command(cmd_to_execute) # affichage de la sortie de la commande for line in ssh_stdout: print('... ' + line.strip('\n')) client.close() outputs={"status":"Unregister minion terminé"} return outputs
def ssh_client(ip, user, private_key_filepath, proxy_settings=None): """ Retrieves and attemts an SSH connection :param ip: the IP of the host to connect :param user: the user with which to connect :param private_key_filepath: the path to the private key file :param proxy_settings: optional proxy settings in the form <hostname|IP>:<port> :return: the SSH client if can connect else false """ import paramiko logger.debug('Retrieving SSH client') ssh = paramiko.SSHClient() ssh.set_missing_host_key_policy(paramiko.MissingHostKeyPolicy()) proxy = None if proxy_settings: logger.debug('Setting up SSH proxy settings') tokens = re.split(':', proxy_settings) proxy = paramiko.ProxyCommand('../ansible/conf/ssh/corkscrew ' + tokens[0] + ' ' + tokens[1] + ' ' + ip + ' 22') logger.info('Attempting to connect to ' + ip) try: ssh.connect(ip, username=user, key_filename=private_key_filepath, sock=proxy) return ssh except Exception as e: logger.warn('Unable to connect via SSH with message - ' + e.message)
def set_sshcfg(self, **kw): node = kw['node'] nodeinfo = kw['nodeinfo'] tmp_remote_dir = "/tmp/%s/.ssh/" % nodeinfo['username'] try: ssh_client = paramiko.SSHClient() ssh_client.set_missing_host_key_policy( paramiko.MissingHostKeyPolicy()) ssh_client.connect(nodeinfo['bmcip'], username=nodeinfo['username'], password=nodeinfo['password']) except (NoValidConnectionsError) as e: return self.callback.error( "Unable to connect to bmc %s" % nodeinfo['bmcip'], node) if not ssh_client.get_transport().is_active(): return self.callback.error( "SSH session to bmc %s is not active" % nodeinfo['bmcip'], node) if not ssh_client.get_transport().is_authenticated(): return self.callback.error( "SSH session to bmc %s is not authenticated" % nodeinfo['bmcip'], node) ssh_client.exec_command("/bin/mkdir -p %s\n" % tmp_remote_dir) scp = SCPClient(ssh_client.get_transport()) scp.put(self.copy_sh_file, tmp_remote_dir + "copy.sh") scp.put(self.local_public_key, tmp_remote_dir + "id_rsa.pub") ssh_client.exec_command("%s/copy.sh %s" % (tmp_remote_dir, nodeinfo['username'])) ssh_client.close() return self.callback.info("ssh keys copied to %s" % nodeinfo['bmcip'])
def _mock_ssh_sftp(self): # SSH self.m.StubOutWithMock(paramiko, "SSHClient") self.m.StubOutWithMock(paramiko, "MissingHostKeyPolicy") ssh = self.m.CreateMockAnything() paramiko.SSHClient().AndReturn(ssh) paramiko.MissingHostKeyPolicy() ssh.set_missing_host_key_policy(None) ssh.connect(mox.IgnoreArg(), key_filename=mox.IgnoreArg(), username='******') stdin = self.m.CreateMockAnything() stdout = self.m.CreateMockAnything() stderr = self.m.CreateMockAnything() stdout.read().AndReturn("stdout") stderr.read().AndReturn("stderr") ssh.exec_command(mox.IgnoreArg()).AndReturn((stdin, stdout, stderr)) # SFTP self.m.StubOutWithMock(paramiko, "Transport") transport = self.m.CreateMockAnything() paramiko.Transport((mox.IgnoreArg(), 22)).AndReturn(transport) transport.connect(hostkey=None, username="******", pkey=mox.IgnoreArg()) sftp = self.m.CreateMockAnything() self.m.StubOutWithMock(paramiko, "SFTPClient") paramiko.SFTPClient.from_transport(transport).AndReturn(sftp) sftp_file = self.m.CreateMockAnything() sftp.open(mox.IgnoreArg(), 'w').AndReturn(sftp_file) sftp_file.write(mox.IgnoreArg()) sftp_file.close() sftp_file = self.m.CreateMockAnything() sftp.open(mox.IgnoreArg(), 'w').AndReturn(sftp_file) sftp_file.write(mox.IgnoreArg()) sftp_file.close()
def upload(host, username, password): import paramiko client = paramiko.SSHClient() client.set_missing_host_key_policy(paramiko.MissingHostKeyPolicy()) logging.info('connect %s', host) client.connect(host, 22, username, password) client.exec_command('mkdir -p /opt/goagent/{vps,log}') logging.info('open sftp...') sftp = client.open_sftp() logging.info('open sftp ok') sftp.chdir('/opt/goagent/vps') uploadlist = ['../local/proxylib.py', 'vps/*'] for filename in sum((glob.glob(x) for x in uploadlist), []): logging.info('upload %s', filename) sftp.put(filename, '/opt/goagent/vps/%s' % os.path.basename(filename)) cmds = [ '/bin/cp -f /opt/goagent/vps/sysctl.conf /etc/', '/bin/cp -f /opt/goagent/vps/limits.conf /etc/security/', '/bin/ln -sf /opt/goagent/vps/goagentvps.sh /etc/init.d/goagentvps', 'chmod +x /opt/goagent/vps/goagentvps.sh', 'which update-rc.d && update-rc.d goagentvps defaults' 'which chkconfig && chkconfig goagentvps on' 'sysctl -p' ] client.exec_command(' ; '.join(cmds)) client.exec_command('/etc/init.d/goagentvps stop') client.exec_command('/etc/init.d/goagentvps start')
def execute_command(self, cmd, ip="", port=22, timeout=7200, environment={}): """Execute a command on a remote machine using ssh. :param cmd: command to be executed on a remote machine. :type cmd: str :param ip: machine's ip. :type ip: str :param port: machine's ssh port. :type port: int :param timout: stop execution after a certain time. :type timeout: int :return: subprocess object containing (returncode, stdout, stderr) """ client = paramiko.SSHClient() client.set_missing_host_key_policy(paramiko.MissingHostKeyPolicy()) client.connect(hostname=ip, port=port, timeout=30) _, stdout, stderr = client.exec_command(cmd, timeout=timeout, environment=environment) try: out = stdout.read().decode() err = stderr.read().decode() rc = stdout.channel.recv_exit_status() except: stdout.channel.close() err = "Error Timeout Exceeded {}".format(timeout) out = "" rc = 124 return Complete_Executuion(rc, out, err)
def __init__(self, host, port, username, password, look_for_keys=True): # noqa too-many-arguments """ Try to connect by SSH to remote server and set attribute client and ftp_client if connected. If not, set attribute init_error to error raised by connection. :param host: host of the server :param port: port of the server :param username: username from server :param password: password for user from server :param look_for_keys: False if password not required """ super().__init__(host, port, username, password) self.look_for_keys = look_for_keys self.client = paramiko.SSHClient() self.client.set_missing_host_key_policy( paramiko.MissingHostKeyPolicy()) self.init_error = None self.ftp_client = None try: self.client.connect( hostname=self.host, port=self.port, username=self.username, password=self.password, look_for_keys=self.look_for_keys, ) self.ftp_client = self.client.open_sftp() except (paramiko.SSHException, gaierror) as error: self.init_error = error self.logger.error(error)
def __init__(self, host, username=None, password=None, pkey=None, port=22, timeout=15, connect=True): self.host = host self.username = username self.password = password if pkey: if isinstance(pkey, paramiko.rsakey.RSAKey): self.pkey = pkey elif isinstance(pkey, str) and os.path.isfile( os.path.expanduser(pkey)): pkey = os.path.expanduser(pkey) self.pkey = paramiko.RSAKey.from_private_key_file(pkey) else: raise DaskEc2Exception( "pkey argument should be filepath or paramiko.rsakey.RSAKey" ) else: self.pkey = None self.port = port self.timeout = timeout self.client = paramiko.SSHClient() self.client.set_missing_host_key_policy( paramiko.MissingHostKeyPolicy()) self._sftp = None if connect: self.connect()
def _run_ssh_command(self, command): """Run a shell command on the Cloud Server via SSH.""" with tempfile.NamedTemporaryFile() as private_key_file: private_key_file.write(self.private_key) private_key_file.seek(0) ssh = paramiko.SSHClient() ssh.set_missing_host_key_policy(paramiko.MissingHostKeyPolicy()) ssh.connect(self.server.accessIPv4, username="******", key_filename=private_key_file.name) chan = ssh.get_transport().open_session() chan.settimeout(self.stack.timeout_mins * 60.0) chan.exec_command(command) try: # The channel timeout only works for read/write operations chan.recv(1024) except socket.timeout: raise exception.Error( _("SSH command timed out after %s " "minutes") % self.stack.timeout_mins) else: return chan.recv_exit_status() finally: ssh.close() chan.close()
def _mock_ssh_sftp(self, exit_code=0): # SSH self.m.StubOutWithMock(paramiko, "SSHClient") self.m.StubOutWithMock(paramiko, "MissingHostKeyPolicy") ssh = self.m.CreateMockAnything() paramiko.SSHClient().AndReturn(ssh) paramiko.MissingHostKeyPolicy() ssh.set_missing_host_key_policy(None) ssh.connect(mox.IgnoreArg(), key_filename=mox.IgnoreArg(), username='******') fake_chan = self.m.CreateMockAnything() self.m.StubOutWithMock(paramiko.SSHClient, "get_transport") chan = ssh.get_transport().AndReturn(fake_chan) fake_chan_session = self.m.CreateMockAnything() chan_session = chan.open_session().AndReturn(fake_chan_session) chan_session.exec_command(mox.IgnoreArg()) chan_session.recv_exit_status().AndReturn(exit_code) # SFTP self.m.StubOutWithMock(paramiko, "Transport") transport = self.m.CreateMockAnything() paramiko.Transport((mox.IgnoreArg(), 22)).AndReturn(transport) transport.connect(hostkey=None, username="******", pkey=mox.IgnoreArg()) sftp = self.m.CreateMockAnything() self.m.StubOutWithMock(paramiko, "SFTPClient") paramiko.SFTPClient.from_transport(transport).AndReturn(sftp) sftp_file = self.m.CreateMockAnything() sftp.open(mox.IgnoreArg(), 'w').AndReturn(sftp_file) sftp_file.write(mox.IgnoreArg()) sftp_file.close() sftp_file = self.m.CreateMockAnything() sftp.open(mox.IgnoreArg(), 'w').AndReturn(sftp_file) sftp_file.write(mox.IgnoreArg()) sftp_file.close()
def ssh(hostname=None, command=None, username=None, password=None,): assert hostname and command and username and password, "ArrayCM.ssh requires valid args" _ssh = paramiko.SSHClient() _ssh.set_missing_host_key_policy(paramiko.MissingHostKeyPolicy()) if hostname: # TODO check hostname validation try: log.debug('_cli_ SSHClient: {!r} SSH_stdin: {!r}'.format(hostname, command)) _ssh.connect(hostname=hostname, username=username, password=password) except(TimeoutError, paramiko.ssh_exception.AuthenticationException, socket.error) as e: raise GenericError(hostname, command, e) else: std_in, std_out, std_err = _ssh.exec_command(command) std_in.flush() _output = std_out.readlines() stdret = std_err.readlines() out_info = None out_error = None out_unknown = None if stdret: if (stdret[0]).split(':')[0] == 'INFO': out_info = stdret elif (stdret[0]).split(':')[0] == 'ERROR': out_error = stdret else: out_unknown = stdret log.debug('_cli_ SSHClient: {!r} SSH_stdout:\n{}'.format(hostname, ''.join(_output))) log.info("SSH:: {} with command: {} - executed successfully".format(hostname, command)) return dict(host=hostname, data=_output, info=out_info, error=out_error, unknown=out_unknown) finally: _ssh.close()
def __init__(self, host, user=None): """Connect to host honoring any user set configuration in ~/.ssh/config or /etc/ssh/ssh_config :type: str :param host: Hostname to connect to :type str: :param user: (Optional) User to login as. Defaults to logged in user or user from ~/.ssh/config if set :throws: paramiko.AuthenticationException on authentication error :throws: ssh_client.UnknownHostException on DNS resolution error :throws: ssh_client.ConnectionErrorException on error connecting""" ssh_config = paramiko.SSHConfig() _ssh_config_file = os.path.sep.join( [os.path.expanduser('~'), '.ssh', 'config']) # Load ~/.ssh/config if it exists to pick up username # and host address if set if os.path.isfile(_ssh_config_file): ssh_config.parse(open(_ssh_config_file)) host_config = ssh_config.lookup(host) resolved_address = (host_config['hostname'] if 'hostname' in host_config else host) _user = host_config['user'] if 'user' in host_config else None if user: user = user else: user = _user client = paramiko.SSHClient() client.set_missing_host_key_policy(paramiko.MissingHostKeyPolicy()) self.client = client self.channel = None self.user = user self.host = resolved_address self._connect()
def initialize_connections(args): global connections global servers for server in servers: client = paramiko.SSHClient() client.set_missing_host_key_policy(paramiko.MissingHostKeyPolicy()) if server["pwd"] == "sshkey" and args.sshkey: try: client.connect(server["IP"], username=server["user"], key_filename=args.sshkey, timeout=args.timeout) except (paramiko.ssh_exception.NoValidConnectionsError, socket.timeout): logging.error("Could not connect to %s@%s" % (server["user"], server["IP"])) continue else: if server["pwd"] == "sshkey" and not args.sshkey: logging.warning( "sshkey defined as password but ssh key not provided!") try: client.connect(server["IP"], username=server["user"], password=server["pwd"], timeout=args.timeout) except (paramiko.ssh_exception.NoValidConnectionsError, socket.timeout): logging.error("Could not connect to %s@%s" % (server["user"], server["IP"])) continue logging.debug("Unsetting HISTORY env in the ssh connection (" + server["IP"] + ")") client.exec_command("unset HISTORY") connections.append([server, client])
def executeSSHcommand_ACCEPT(server, login, password, command): client = paramiko.SSHClient() client.set_missing_host_key_policy( paramiko.MissingHostKeyPolicy()) # pas de check de clé client.connect(server, username=login, password=password) ssh_stdin, ssh_stdout, ssh_stderr = client.exec_command(command) client.close() return 0
def connect_to_host(self, host, username, password): self.ssh = paramiko.SSHClient() self.ssh.load_system_host_keys() self.ssh.set_missing_host_key_policy(paramiko.MissingHostKeyPolicy()) self.ssh.connect(host, username=username, password=password, timeout=10.0)
def _check(self): c = paramiko.SSHClient() c.set_missing_host_key_policy(paramiko.MissingHostKeyPolicy()) # ignore unknown hosts c.connect(hostname=str(self.target), username=self.username, password=self.password) stdin, stdout, stderr = c.exec_command('uname -a') evidence = stdout.readlines()[0] c.close() return evidence
def connect(self): self.client = paramiko.SSHClient() self.client.set_missing_host_key_policy( paramiko.MissingHostKeyPolicy()) self.client.connect(self.ip, self.port, username=YB_USERNAME, key_filename=self.key_filename, timeout=10)
def __init__(self): # self.default_xml_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), "server_config.xml") self.paramiko_log_file = os.path.join(os.path.dirname(__file__), "paramiko.log") self.set_paramiko_log_file() self.ssh = paramiko.SSHClient() self.ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) self.ssh.set_missing_host_key_policy(paramiko.MissingHostKeyPolicy()) self.version = "version 0.3"
def __init__(self, instance, username, key_filename, timeout=10): super(SSHClient, self).__init__() self.set_missing_host_key_policy(paramiko.MissingHostKeyPolicy()) self.instance = instance self.username = username self.key_filename = key_filename self.ip = instance.private_ip_address self.name = instance.tags.get("Name") self.timeout = timeout