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