def __init__( self, remote_host, remote_port, username=None, password=None, key_file=None, timeout=10, keepalive_interval=30, compress=True, no_host_key_check=True, allow_host_key_change=False, logger=None, ): self.remote_host = check.str_param(remote_host, 'remote_host') self.remote_port = check.opt_int_param(remote_port, 'remote_port') self.username = check.opt_str_param(username, 'username') self.password = check.opt_str_param(password, 'password') self.key_file = check.opt_str_param(key_file, 'key_file') self.timeout = check.opt_int_param(timeout, 'timeout') self.keepalive_interval = check.opt_int_param(keepalive_interval, 'keepalive_interval') self.compress = check.opt_bool_param(compress, 'compress') self.no_host_key_check = check.opt_bool_param(no_host_key_check, 'no_host_key_check') self.allow_host_key_change = check.opt_bool_param( allow_host_key_change, 'allow_host_key_change') self.log = logger self.host_proxy = None # Auto detecting username values from system if not self.username: logger.debug( 'username to ssh to host: %s is not specified. Using system\'s default provided by' ' getpass.getuser()' % self.remote_host) self.username = getpass.getuser() user_ssh_config_filename = os.path.expanduser('~/.ssh/config') if os.path.isfile(user_ssh_config_filename): ssh_conf = paramiko.SSHConfig() ssh_conf.parse(open(user_ssh_config_filename)) host_info = ssh_conf.lookup(self.remote_host) if host_info and host_info.get('proxycommand'): self.host_proxy = paramiko.ProxyCommand( host_info.get('proxycommand')) if not (self.password or self.key_file): if host_info and host_info.get('identityfile'): self.key_file = host_info.get('identityfile')[0]
def _use_ssh_config(self, dict_arg): """ Update SSH connection parameters based on contents of SSH 'config' file. :param dict_arg: Dictionary of SSH connection parameters :type dict_arg: dict """ connect_dict = dict_arg.copy() # Use SSHConfig to generate source content. full_path = path.abspath(path.expanduser(self.ssh_config_file)) if path.exists(full_path): ssh_config_instance = paramiko.SSHConfig() with io.open(full_path, "rt", encoding='utf-8') as f: ssh_config_instance.parse(f) source = ssh_config_instance.lookup(self.host) else: source = {} if source.get('proxycommand'): proxy = paramiko.ProxyCommand(source['proxycommand']) elif source.get('ProxyCommand'): proxy = paramiko.ProxyCommand(source['proxycommand']) else: proxy = None # Only update 'hostname', 'sock', 'port', and 'username' # For 'port' and 'username' only update if using object defaults if connect_dict['port'] == 22: connect_dict['port'] = int(source.get('port', self.port)) if connect_dict['username'] == '': connect_dict['username'] = source.get('username', self.username) if proxy: connect_dict['sock'] = proxy connect_dict['hostname'] = source.get('hostname', self.host) return connect_dict
def execute_command_via_gateway(cmd, host, username, private_key_filename, gateway_host, gateway_username=None, proxy_command=None, password=None, private_key=None): LOG.debug('Creating SSH connection') private_key = _to_paramiko_private_key(private_key_filename, private_key, password) proxy = None if proxy_command: LOG.debug('Creating proxy using command: %s', proxy_command) proxy = paramiko.ProxyCommand(proxy_command) _proxy_ssh_client = paramiko.SSHClient() _proxy_ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) LOG.debug('Connecting to proxy gateway at: %s', gateway_host) if not gateway_username: gateway_username = username _proxy_ssh_client.connect(gateway_host, username=gateway_username, pkey=private_key, sock=proxy) proxy = _proxy_ssh_client.get_transport().open_session() proxy.exec_command("nc {0} 22".format(host)) ssh_client = _connect(host, username=username, pkey=private_key, proxy=proxy) try: return _execute_command(ssh_client, cmd, get_stderr=False, raise_when_error=True) finally: _cleanup(_proxy_ssh_client)
def node_shell(hostname, siteUser, sitePasswd, connectTimeout, cmdTimeout): ssh = paramiko.SSHClient() ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) try: if not args.proxyPort: ssh.connect(hostname, username=siteUser, password=sitePasswd, timeout=connectTimeout, banner_timeout=connectTimeout, look_for_keys=False) logger.debug('Connected: %s, %s, %s, proxy disabled' % (hostname, siteUser, connectTimeout)) else: proxyPort = int(args.proxyPort) proxyCommandStr = "nc -X 5 -x localhost:%s %s %s" % ( proxyPort, hostname, '22') proxySock = paramiko.ProxyCommand(proxyCommandStr) ssh.connect(hostname, username=siteUser, password=sitePasswd, timeout=connectTimeout, banner_timeout=connectTimeout, sock=proxySock, look_for_keys=False) logger.debug('Connected: %s, %s, %s, proxy enabled' % (hostname, siteUser, connectTimeout)) transport = ssh.get_transport() transport.set_keepalive(0) if args.commandFile: try: cmds = open(args.commandFile) cmds = [cmd.strip() for cmd in cmds] except Exception as e: logger.error(e) else: cmd = args.commandString cmds = [cmd] run_cmds(ssh, cmds, hostname, sitePasswd, cmdTimeout) successful_logins.append(hostname) except Exception as e: ssh.close() logger.debug('ssh closed') logger.error('%s: failed to login : %s' % (hostname, e)) failed_logins.append(hostname)
def _login_with_public_key(self, username, key_file, password, allow_agent, look_for_keys, proxy_cmd=None, jumphost_connection=None, read_config_host=False): if read_config_host: self.config.host = self._read_ssh_config_host(self.config.host) try: sock_tunnel = None if proxy_cmd and not jumphost_connection: sock_tunnel = paramiko.ProxyCommand(proxy_cmd) elif jumphost_connection and not proxy_cmd: dest_addr = (self.config.host, self.config.port) jump_addr = (jumphost_connection.config.host, jumphost_connection.config.port) jumphost_transport = jumphost_connection.client.get_transport() if not jumphost_transport: raise RuntimeError( "Could not get transport for {}:{}. Have you logged in?" .format(*jump_addr)) sock_tunnel = jumphost_transport.open_channel( "direct-tcpip", dest_addr, jump_addr) elif proxy_cmd and jumphost_connection: raise ValueError( "`proxy_cmd` and `jumphost_connection` are mutually exclusive SSH features." ) self.client.connect(self.config.host, self.config.port, username, password, key_filename=key_file, allow_agent=allow_agent, look_for_keys=look_for_keys, timeout=float(self.config.timeout), sock=sock_tunnel) except paramiko.AuthenticationException: try: transport = self.client.get_transport() try: transport.auth_none(username) except: pass transport.auth_publickey(username, None) except Exception as err: raise SSHClientException
def open( self, hostname: Optional[str], username: Optional[str], password: Optional[str], port: Optional[int], platform: Optional[str], extras: Optional[Dict[str, Any]] = None, configuration: Optional[Config] = None, ) -> None: extras = extras or {} client = paramiko.SSHClient() client._policy = paramiko.WarningPolicy() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) ssh_config = paramiko.SSHConfig() ssh_config_file = configuration.ssh.config_file # type: ignore if os.path.exists(ssh_config_file): with open(ssh_config_file) as f: ssh_config.parse(f) parameters = { "hostname": hostname, "username": username, "password": password, "port": port, } user_config = ssh_config.lookup(hostname) for k in ("hostname", "username", "port"): if k in user_config: parameters[k] = user_config[k] if "proxycommand" in user_config: parameters["sock"] = paramiko.ProxyCommand( user_config["proxycommand"]) self.state["ssh_forward_agent"] = user_config.get( "forwardagent") == "yes" # TODO configurable # if ssh_key_file: # parameters['key_filename'] = ssh_key_file if "identityfile" in user_config: parameters["key_filename"] = user_config["identityfile"] extras.update(parameters) client.connect(**extras) self.connection = client
def _connect(host, username, private_key, proxy_command=None): global _ssh LOG.debug('Creating SSH connection') if type(private_key) in [str, unicode]: private_key = crypto.to_paramiko_private_key(private_key) _ssh = paramiko.SSHClient() _ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) proxy = None if proxy_command: LOG.debug('creating proxy using command: {0}'.format(proxy_command)) proxy = paramiko.ProxyCommand(proxy_command) _ssh.connect(host, username=username, pkey=private_key, sock=proxy)
def secure_copy(user, host, src, dest, key_filename=None, allow_agent=True): keys = _load_keys(key_filename, allow_agent) pkey = keys[0] ssh = paramiko.SSHClient() conf = paramiko.SSHConfig() ssh_config_file = os.path.expanduser("~/.ssh/config") conf.parse(open(ssh_config_file)) host_config = conf.lookup(host) proxy = paramiko.ProxyCommand(host_config['proxycommand']) ssh.load_system_host_keys() ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) ssh.connect(host, username=user, pkey=pkey, sock=proxy) scp = SCPClient(ssh.get_transport()) scp.get(src, dest) scp.close()
def test_client(host_name): conf = paramiko.SSHConfig() conf.parse(open(os.path.expanduser('~/.ssh/config'))) host = conf.lookup(host_name) client = paramiko.SSHClient() client.load_system_host_keys() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) client.connect(host['hostname'], username=host['user'], key_filename=host['identityfile'], sock=paramiko.ProxyCommand(host.get('proxycommand'))) stdin, stdout, stderr = client.exec_command('ls /home') print stdout.read() stdin, stdout, stderr = client.exec_command('ls /') print stdout.read()
def ssh_config_run(host, cmd): ssh = paramiko.SSHClient() ssh.load_system_host_keys() ssh._policy = paramiko.WarningPolicy() #ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) ssh_config = paramiko.SSHConfig() user_config_file = os.path.expanduser("~/.ssh/config") try: with open(user_config_file) as f: ssh_config.parse(f) except: print("{} file could not be found. Aborting.".format(user_config_file)) sys.exit(1) user_config = ssh_config.lookup(host) cfg = { 'hostname': user_config['hostname'], 'username': user_config['user'], 'look_for_keys': False } if 'proxycommand' in user_config: cfg['sock'] = paramiko.ProxyCommand(user_config['proxycommand']) ssh.connect(**cfg) for m in cmd: print(host, m) if m[:4] == 'sudo': transport = ssh.get_transport() session = transport.open_session() session.set_combine_stderr(True) session.get_pty() session.exec_command(m) stdin = session.makefile('wb', -1) stdout = session.makefile('rb', -1) stdin.write('Ranchyang!1\n') stdin.flush() for line in stdout.read().splitlines(): print(host, line) continue stdin, stdout, stderr = ssh.exec_command(m) outt = stdout.readlines() for o in outt: print(host, 'out', o) err = stderr.readlines() for e in err: print(host, 'err', e) ssh.close()
def LIST_selectST(self): import paramiko client = paramiko.SSHClient() ssh_config = paramiko.SSHConfig() client._policy = paramiko.WarningPolicy() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) user_config_file = os.path.expanduser(self.CONFIG_FILE) try: with open(user_config_file) as f: ssh_config.parse(f) except FileNotFoundError: print("{} file could not be found. Aborting.".format( user_config_file)) sys.exit(1) user_config = ssh_config.lookup(self.IP) if 'proxycommand' in user_config: user_config['sock'] = paramiko.ProxyCommand( user_config['proxycommand']) del user_config['proxycommand'] if 'user' in user_config: user_config['username'] = user_config['user'] del user_config['user'] client.connect(**user_config) stdin, stdout, stderr = client.exec_command('df -l \ | awk \' !/maha/ {if(length($2)> 9 && NR!=1) \ print substr($0,index($0,$2))}\'') TOTAL_LIST = [] LEN = 5 for line in [line.strip().split() for line in stdout.readlines()]: stdin2, stdout2, stderr2 = client.exec_command( 'find %s -maxdepth 1 -type d ! -name \'lost+found\' \ | sed 1d \ |awk \'{split($0,a,"/"); print a[length(a)]}\'' % line[-1]) all_list = [a.strip() for a in stdout2.readlines()] if len(all_list) >= LEN: all_list = all_list[:LEN - 1] + ['...'] line.append(', '.join(all_list)) TOTAL_LIST.append(line) return TOTAL_LIST
def open(self): self._client = SSHClient() self._client.load_system_host_keys() self._client.set_missing_host_key_policy(WarningPolicy()) print(f'Connecting to {self.username}@{self.hostname}') if self.proxy_command: print('ProxyCommand:', self.proxy_command) sock = (paramiko.ProxyCommand(self.proxy_command) if self.proxy_command else None) try: self._client.connect(hostname=self.hostname, username=self.username, sock=sock, key_filename=self.key_filenames) except paramiko.ssh_exception.BadHostKeyException: sys.exit('Connection error: bad host key') self._transport = self._client.get_transport()
def get_ssh_client(self, host_name, ssh_config_path): conf = paramiko.SSHConfig() conf.parse(open(os.path.expanduser(ssh_config_path))) host = conf.lookup(host_name) client = paramiko.SSHClient() client.load_system_host_keys() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) client.connect( host['hostname'], username=host['user'], # key_filename=host['identityfile'], sock=paramiko.ProxyCommand(host.get('proxycommand'))) print('CREATE SSH CLIENT') return client
def sendDirsToIMR(dirs, vaspfiles): print("type your passwd for IMR supercomputer node") passwd = getpass() config_file = os.path.join(os.getenv('HOME'), '.ssh/config') ssh_config = paramiko.SSHConfig() ssh_config.parse(open(config_file, 'r')) lkup = ssh_config.lookup('super.imr') # ProxyCommand setup ssh = paramiko.SSHClient() ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) ssh.load_system_host_keys() print("what found in config file") print(lkup) ssh.connect(lkup['hostname'], username=lkup['user'], sock=paramiko.ProxyCommand(lkup['proxycommand']), password=passwd) sftp = ssh.open_sftp() workingdir = '/home/emi0716/work/' for i in dirs: mkdircommand = 'mkdir ' + workingdir + i stdin, stdout, stderr = ssh.exec_command(mkdircommand) outlines = stdout.readlines() result = ''.join(outlines) print("making dirs:" + result) for i in dirs: #TODO catch stderr for f in vaspfiles: origin = "./" + i + "/" + f print("origin:" + origin) #print(os.path.exists(origin)) target = workingdir + i + "/" + f print("target:" + target) sftp.put(origin, target) with open("alldirs-" + str(datetime.date.today()) + ".txt", "w") as f: for i in dirs: f.write(str(workingdir + i) + '\n') sftp.close() ssh.close()
def connect(hostname, port, ssh_key_file, passphrase, user): # If we are in a localhost case, don't play with ssh if is_local(hostname): return LocalExec() # Maybe paramiko is missing, but now we relly need ssh... if paramiko is None: print "ERROR : this plugin needs the python-paramiko module. Please install it" sys.exit(2) if not os.path.exists(os.path.expanduser(ssh_key_file)): err = "Error : missing ssh key file. please specify it with -i parameter" raise Exception(err) ssh_key_file = os.path.expanduser(ssh_key_file) client = paramiko.SSHClient() client.load_system_host_keys() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) 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) cfg = { 'hostname': hostname, 'port': port, 'username': user, 'key_filename': ssh_key_file, 'password': passphrase } user_config = ssh_config.lookup(cfg['hostname']) for k in ('hostname', port, 'username', 'key_filename', 'password'): if k in user_config: cfg[k] = user_config[k] if 'proxycommand' in user_config: cfg['sock'] = paramiko.ProxyCommand(user_config['proxycommand']) try: client.connect(**cfg) except Exception, exp: err = "Error : connexion failed '%s'" % exp print err sys.exit(2)
def _parse_proxy_command(self, port=22): proxy_command = None # Parse ansible_ssh_common_args, specifically looking for ProxyCommand ssh_args = [ getattr(self._play_context, 'ssh_extra_args', '') or '', getattr(self._play_context, 'ssh_common_args', '') or '', getattr(self._play_context, 'ssh_args', '') or '', ] if ssh_args is not None: args = self._split_ssh_args(' '.join(ssh_args)) for i, arg in enumerate(args): if arg.lower() == 'proxycommand': # _split_ssh_args split ProxyCommand from the command itself proxy_command = args[i + 1] else: # ProxyCommand and the command itself are a single string match = SETTINGS_REGEX.match(arg) if match: if match.group(1).lower() == 'proxycommand': proxy_command = match.group(2) if proxy_command: break proxy_command = proxy_command or self.get_option('proxy_command') sock_kwarg = {} if proxy_command: replacers = { '%h': self._play_context.remote_addr, '%p': port, '%r': self._play_context.remote_user } for find, replace in replacers.items(): proxy_command = proxy_command.replace(find, str(replace)) try: sock_kwarg = {'sock': paramiko.ProxyCommand(proxy_command)} display.vvv("CONFIGURE PROXY COMMAND FOR CONNECTION: %s" % proxy_command, host=self._play_context.remote_addr) except AttributeError: display.warning('Paramiko ProxyCommand support unavailable. ' 'Please upgrade to Paramiko 1.9.0 or newer. ' 'Not using configured ProxyCommand') return sock_kwarg
def __init__(self, base_url, timeout=60, pool_connections=constants.DEFAULT_NUM_POOLS, *args, **kwargs): logging.getLogger("paramiko").setLevel(logging.WARNING) self.ssh_client = paramiko.SSHClient() base_url = six.moves.urllib_parse.urlparse(base_url) self.ssh_params = { "hostname": base_url.hostname, "port": base_url.port, "username": base_url.username } ssh_config_file = os.path.expanduser("~/.ssh/config") if os.path.exists(ssh_config_file): conf = paramiko.SSHConfig() with open(ssh_config_file) as f: conf.parse(f) host_config = conf.lookup(base_url.hostname) self.ssh_conf = host_config if 'proxycommand' in host_config: self.ssh_params["sock"] = paramiko.ProxyCommand( self.ssh_conf['proxycommand']) if 'hostname' in host_config: self.ssh_params['hostname'] = host_config['hostname'] if base_url.port is None and 'port' in host_config: self.ssh_params['port'] = self.ssh_conf['port'] if base_url.username is None and 'user' in host_config: self.ssh_params['username'] = self.ssh_conf['user'] if "pkey_str" in kwargs: self.ssh_params["pkey"] = paramiko.RSAKey.from_private_key( io.StringIO(kwargs.get("pkey_str"))) if "pkey" in kwargs: self.ssh_params["pkey"] = kwargs.get("pkey") self.ssh_client.load_system_host_keys() self.ssh_client.set_missing_host_key_policy( kwargs.get("hostKeyPolicy", paramiko.WarningPolicy())) self._connect() self.timeout = timeout self.pools = RecentlyUsedContainer(pool_connections, dispose_func=lambda p: p.close()) super(SSHHTTPAdapter, self).__init__()
def __init__(self, **config): super().__init__(**config) url = config.get("url") if url: parsed = urlparse(url) user_ssh_config = self._load_user_ssh_config(parsed.hostname) host = user_ssh_config.get("hostname", parsed.hostname) user = ( config.get("user") or parsed.username or user_ssh_config.get("user") or getpass.getuser() ) port = ( config.get("port") or parsed.port or self._try_get_ssh_config_port(user_ssh_config) or self.DEFAULT_PORT ) self.path_info = self.PATH_CLS.from_parts( scheme=self.scheme, host=host, user=user, port=port, path=parsed.path, ) else: self.path_info = None user_ssh_config = {} self.keyfile = config.get( "keyfile" ) or self._try_get_ssh_config_keyfile(user_ssh_config) self.timeout = config.get("timeout", self.TIMEOUT) self.password = config.get("password", None) self.ask_password = config.get("ask_password", False) self.gss_auth = config.get("gss_auth", False) proxy_command = user_ssh_config.get("proxycommand", False) if proxy_command: import paramiko self.sock = paramiko.ProxyCommand(proxy_command) else: self.sock = None self.allow_agent = config.get("allow_agent", True)
def fill_in_srvdict(self): ssh_config = paramiko.SSHConfig() if os.path.exists(self.__user_config_file): with open(self.__user_config_file) as f: ssh_config.parse(f) for srv in self.srvlist: host=ssh_config.lookup(srv) if 'hostname' in host: hostname=host['hostname'].replace('\t',' ') else: hostname=srv if 'proxycommand' in host: proxycmd=host['proxycommand'].replace('\t',' ') proxy=paramiko.ProxyCommand(proxycmd) else: proxy=None self.srvdict[srv]=dict(dict(hostname=hostname,proxy=proxy))
def connect(self): """Connect to ssh server.""" if not self.closed: raise RuntimeError('SSH is already opened') sock = paramiko.ProxyCommand(self._proxy_cmd) \ if self._proxy_cmd else None self._ssh = paramiko.SSHClient() self._ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) self._ssh.connect(self._host, self._port, pkey=self._pkey, timeout=self._timeout, banner_timeout=self._timeout, username=self._username, password=self._password, sock=sock)
def _get_ssh_client(self): config = paramiko.SSHConfig() config.parse(open(os.path.expanduser('~/.ssh/config'))) host = config.lookup(self.inputs.hostname) if 'proxycommand' in host: proxy = paramiko.ProxyCommand( subprocess.check_output( [os.environ['SHELL'], '-c', 'echo %s' % host['proxycommand']]).strip()) else: proxy = None client = paramiko.SSHClient() client.load_system_host_keys() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) client.connect(host['172.16.37.254'], username=host['grant.stokley'], sock=proxy) return client
def __init__(self, metapath, clean_remote=False, retrieve=True): self.metadata_path = Path(metapath) if not self.metadata_path.is_file(): raise FileNotFoundError("Cluster run metadata file not found: {}".format(self.metadata_path.as_posix())) self.metadata = self.load_metadata() submission_time = datetime.strptime(self.metadata['timestamp'], '%Y-%m-%d %H:%M:%S') time_diff = datetime.now() - submission_time # let's wait for at least 30 seconds after job submissions and then look for results while time_diff.seconds < 5: time.sleep(1) time_diff = datetime.now() - submission_time self.client = paramiko.SSHClient() self.client.load_system_host_keys() self.client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) if 'CLUSTERPASS' in os.environ.keys(): self.password = os.environ['CLUSTERPASS'] else: self.password = getpass.getpass('Enter password for user {}: '.format(self.metadata['cluster_username'])) if self.metadata['cluster_login_node'] != '--': print(" - Connecting to login node {}".format(self.metadata['cluster_login_node'])) sock = paramiko.ProxyCommand("ssh {}@{} nc {} 22".format(self.metadata['cluster_username'], self.metadata['cluster_login_node'], self.metadata['cluster_address'])) sock.settimeout(30) self.client.connect(self.metadata['cluster_address'], port=22, username=self.metadata['cluster_username'], password=self.password, sock=sock) else: self.client.connect(self.metadata['cluster_address'], port=22, username=self.metadata['cluster_username'], password=self.password) self.scpclient = SCPClient(self.client.get_transport()) time.sleep(1) if not Path(self.metadata['local_workspace']).is_dir(): os.mkdir(self.metadata['local_workspace']) if retrieve: self.retrieve() if clean_remote: self.clean_remote() self.client.close()
def ssh_client(host): """Start an ssh client. The ssh client will attempt to use configs from the user's local ssh config in ~/.ssh/config. :param host: the host :type host: str :returns: ssh client :rtype: Paramiko client """ client = paramiko.SSHClient() client._policy = paramiko.WarningPolicy() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) # parse local user ssh 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) cfg = {'hostname': host, 'username': getpass.getuser()} user_config = ssh_config.lookup(cfg['hostname']) logging.debug("Local user ssh config for host {host}: {user_config}".format(host=host, user_config=user_config)) for k in ('hostname', 'port'): if k in user_config: cfg[k] = user_config[k] if 'user' in user_config: cfg['username'] = user_config['user'] if 'proxycommand' in user_config: cfg['sock'] = paramiko.ProxyCommand(user_config['proxycommand']) if 'identityfile' in user_config: cfg['key_filename'] = user_config['identityfile'] logging.debug("Overriden ssh config for {host}: {cfg}".format(host=host, cfg=cfg)) client.connect(**cfg) return client
def ssh_proxy_sock(hostname=None, port=None, command=None, client=None, source_address=None, timeout=None, connection_attempts=None, connection_interval=None): if not command: if client: # I need a command to execute with proxy client options = [] if source_address: options += ['-s', str(source_address)] command = ['nc'] + options + ['{hostname!s}', '{port!s}'] elif not command: # Proxy sock is not required return None # Apply connect parameters to proxy command if not isinstance(command, str): command = subprocess.list2cmdline(command) if hostname: command = command.format(hostname=hostname, port=(port or 22)) if client: if isinstance(client, SSHClientFixture): # Connect to proxy server client = client.connect(connection_timeout=timeout, connection_attempts=connection_attempts, connection_interval=connection_interval) elif not isinstance(client, paramiko.SSHClient): message = "Object {!r} is not an SSHClient".format(client) raise TypeError(message) # Open proxy channel LOG.debug("Execute proxy command with proxy client %r: %r", client, command) sock = client.get_transport().open_session(timeout=timeout) sock.exec_command(command) else: LOG.debug("Execute proxy command on local host: %r", command) sock = paramiko.ProxyCommand(command) return sock
def getSSHConnection(ttip, ip, prot, name, pwd): # setup SSH client client = SSHClient() client.load_system_host_keys() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) # #Check for proxy settings try: proxy = paramiko.ProxyCommand("ssh -o StrictHostKeyChecking=no " + ttuser + "@" + ttip + " nc " + ip + " " + ttport) except: print 1 #Setup the SSH connection try: client.connect(ip, prot, username=name, password=pwd, sock=proxy) except SSHException, ex: print ex
def _login(self, username, password, allow_agent=False, look_for_keys=False, proxy_cmd=None, read_config_host=False, jumphost_connection=None): if read_config_host: self.config.host = self._read_ssh_config_host(self.config.host) sock_tunnel = None if proxy_cmd and jumphost_connection: raise ValueError("`proxy_cmd` and `jumphost_connection` are mutually exclusive SSH features.") elif proxy_cmd: sock_tunnel = paramiko.ProxyCommand(proxy_cmd) elif jumphost_connection: sock_tunnel = self._get_jumphost_tunnel(jumphost_connection) try: if not password and not allow_agent: # If no password is given, try login without authentication try: self.client.connect(self.config.host, self.config.port, username, password, look_for_keys=look_for_keys, allow_agent=allow_agent, timeout=float(self.config.timeout), sock=sock_tunnel) except paramiko.SSHException: pass transport = self.client.get_transport() transport.auth_none(username) else: try: self.client.connect(self.config.host, self.config.port, username, password, look_for_keys=look_for_keys, allow_agent=allow_agent, timeout=float(self.config.timeout), sock=sock_tunnel) except paramiko.AuthenticationException: try: transport = self.client.get_transport() try: transport.auth_none(username) except: pass transport.auth_password(username, password) except: raise SSHClientException except paramiko.AuthenticationException: raise SSHClientException
def open_ssh(self, id): try: os.system("rm ~/.ssh/known_hosts > /dev/null 2>&1") ssh = paramiko.SSHClient() ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) ip = str(self.store.get_attr("base", id, "base.net.ip")).strip() password = str(self.store.get_attr( "base", id, "base.ssh.password")).strip() username = str(self.store.get_attr( "base", id, "base.ssh.user")).strip() port = self.store.get_attr( "base", id, "base.ssh.port") tunnel = self.find_tunnel(id) if tunnel != None: tip = str(self.store.get_attr( "base", tunnel, "base.tunnel.ip")).strip() tport = self.store.get_attr( "base", tunnel, "base.tunnel.port") tuser = str(self.store.get_attr( "base", tunnel, "base.tunnel.user")).strip() tpass = str(self.store.get_attr( "base", tunnel, "base.tunnel.password")).strip() source = "sshpass -p" source += tpass.replace("!", "\\!") source += " ssh -p " source += ("22" if tport == None or tport == "" else str(tport)) source += " -o StrictHostKeyChecking=no " source += tuser source += "@" source += tip source += " nc -w 15 "+ip+" " + \ ("22" if port == None or port == "" else str(port)) proxy = paramiko.ProxyCommand(source) ssh.connect(ip, username=username, password=password, sock=proxy, timeout=5) else: ssh.connect(ip, username=username, password=password, timeout=5) return ssh except: return None
def jobSubmitIMR(dirs): config_file = os.path.join(os.getenv('HOME'), '.ssh/config') ssh_config = paramiko.SSHConfig() ssh_config.parse(open(config_file, 'r')) lkup = ssh_config.lookup('super.imr') print("type your passwd for IMR supercomputer node") passwd = getpass() # ProxyCommand setup ssh = paramiko.SSHClient() ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) ssh.load_system_host_keys() print("what found in config file") print(lkup) ssh.connect(lkup['hostname'], username=lkup['user'], sock=paramiko.ProxyCommand(lkup['proxycommand']), password=passwd) workingdir = '/home/emi0716/work/' jobcommand = "qsub run_imr.sh" joblogfile = 'joblog-' + str(datetime.datetime.now()) + '.txt' f = open(joblogfile, 'w') for i in dirs: print(i) chdircommand = "cd " + i stdin, stdout, stderr = ssh.exec_command(chdircommand + ";" + "pwd;" + jobcommand) outlines = stdout.readlines() result = ''.join(outlines) err = stderr.readlines() print(result) print(err) f.write(result) f.flush() f.close()
def get_gateway(host, port, cache, replace=False): """ Create and return a gateway socket, if one is needed. This function checks ``env`` for gateway or proxy-command settings and returns the necessary socket-like object for use by a final host connection. :param host: Hostname of target server. :param port: Port to connect to on target server. :param cache: A ``HostConnectionCache`` object, in which gateway ``SSHClient`` objects are to be retrieved/cached. :param replace: Whether to forcibly replace a cached gateway client object. :returns: A ``socket.socket``-like object, or ``None`` if none was created. """ from fabric.state import env, output sock = None proxy_command = ssh_config().get('proxycommand', None) if env.gateway: gateway = normalize_to_string(env.gateway) # ensure initial gateway connection if replace or gateway not in cache: if output.debug: logging.debug("Creating new gateway connection to %r" % gateway) cache[gateway] = connect(*normalize(gateway) + (cache, False)) # now we should have an open gw connection and can ask it for a # direct-tcpip channel to the real target. (bypass cache's own # __getitem__ override to avoid hilarity - this is usually called # within that method.) sock = direct_tcpip(dict.__getitem__(cache, gateway), host, port) elif proxy_command: sock = ssh.ProxyCommand(proxy_command) return sock
def sshObjectInit(self, host=None): """""" logText = self.getLogFunction() if not host: host = self.configDict['host'] ssh_config = paramiko.SSHConfig() user_config_file = os.path.expanduser("~/.ssh/config") try: with open(user_config_file) as f: ssh_config.parse(f) except: logText("Could not parse ~/.ssh/config, does the file exist?") return None try: hpcConfig = ssh_config.lookup(host) proxy = paramiko.ProxyCommand(hpcConfig['proxycommand']) assert hpcConfig['hostname'] assert hpcConfig['user'] except: logText( "host configuration seems to be incorrect. the host must be " "configured to have a hostname, username and proxy command.") return None try: client = paramiko.SSHClient() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) client.load_system_host_keys() client.connect(hpcConfig['hostname'], username=hpcConfig['user'], sock=proxy) client.get_transport().set_keepalive(15) self.sshAlive = True return client except: logText("failed to connect to the hpc, internet not working?") return None