def exec(self, sym, data5min, ex1: Exchange, ord_log=None, strat_log=None): # print(data5min) # print("-----") # print(data1hour) # print("-------------------------") self.symbol = sym self.ex1 = ex1 # print(str((float(data5min.iloc[101]['t1'])))) if (len(data5min) == 252) and ((float(data5min.iloc[251]['t1']) - float(data5min.iloc[0]['t1'])) == 251 * 5 * 60 * 1000): last_ts = float(data5min.iloc[251]['t1']) tsorder = util.Util().get_5min_order(last_ts) # print(str(tsorder)) # if tsorder == float(1): if False: print("not checking 1st hour candle in 1 hour timeframe") else: # print("data ok") datac = n3data.Data() self.data = data5min self.datah = datac.geth(self.data) self.currentts = float(data5min.iloc[251]['t1']) # print(data5min) # self.ts = data5min.iloc[100]['t1'] # self.lasto = data5min.iloc[100]['open'] # self.lasth = data5min.iloc[100]['high'] # self.lastl = data5min.iloc[100]['low'] self.lastc = data5min.iloc[251]['close'] # # self.candles = "["+str(self.ts)+","+str(self.lasto)+","+str(self.lasth)+","+str(self.lastl)+","+str(self.lastc)+"]" # self.candle = [] # self.candle.append(self.ts) # self.candle.append(self.lasto) # self.candle.append(self.lasth) # self.candle.append(self.lastl) # self.candle.append(self.lastc) self.symbol = sym.upper() # datac = data.Data() self.data = data5min # self.datah = datac.geth(self.data) # self.datah = self.datah.reindex(index=self.datah.index[::-1]) # self.cch = data1hour['trend_cci'] # self.cc5l = 0 # self.cc5n = 0 # self.ccbb = 0 # self.cc5h = 0 # self.ex = exch self.ord_log = ord_log self.strat_log = strat_log self.ta() self.decide() self.update_positions() else: print("data corrupt ..." + self.symbol)
def generate(fontName, pointSize=12): pilFontFallback = ImageFont.truetype(util.fontFallback, pointSize) pilFont = ImageFont.truetype(fontName, pointSize) Util = util.Util(fontName, pointSize) # Range is exclusive, so + 1 maxGridSize = round(Util.getTextWidth(9608)) lineHeight = int(16.5) # 22 if not exists("img/"): mkdir("img") for c in range(0, 129995): size = Util.getTextWidth(c) ch = chr(c) if size is None or size > maxGridSize or combining(ch) or isRTL(ch): continue image = Image.new("L", (maxGridSize, lineHeight), (0)) draw = ImageDraw.Draw(image) draw.text((0, 0), ch, font=(pilFont if c in Util.t and Util.t[c] in Util.s else pilFontFallback), fill=(255)) bbox = image.getbbox() if not bbox: # Image is empty continue image.save("img/{}.png".format(c)) image.close()
def __init__(self, layer, n_input, n_output): self.util = u.Util() self.sess = tf.Session() self.layer = layer # zero means random! self.n_input = n_input self.n_output = n_output self.train_step = self.layer_set()
def main(): u = util.Util() a = app.App() creds_b64 = a.get_creds("creds.json") plaintext_sudo_password = u.b64_decrypt(creds_b64["sudo_password"]) plaintext_ssh_user = u.b64_decrypt(creds_b64["ssh_user"]) plaintext_ssh_password = u.b64_decrypt(creds_b64["ssh_password"]) all_cmds = a.get_array_cmd("cmds.json", plaintext_sudo_password) # File with IPs serv_lst = "srv.txt" # Open IP file with open(serv_lst, "r") as f: text = f.readlines() # for-loop for IP list for lineHost in text: lineHost = lineHost.replace("\n", "") # Connect SSH print("[+]Connecting Addr::" + lineHost) for c_cmd in all_cmds: ret = conn_ssh(lineHost, plaintext_ssh_user, plaintext_ssh_password, c_cmd) with open("log.log", "a", encoding="utf-8") as fp: all_output = ret["stdout"] + ret["stderr"] fp.write(all_output) fp.close() print("SOC Output Results")
def __init__(self) -> None: self.install = False self.updated_files: Set[str] = set([]) self.util = util.Util() self.python = python.Python() self.python.util = self.util self.node = node.Node() self.node.util = self.util
def get_config(): a = app.App() utils = util.Util() config = a.get_creds("config.json") ip = config["ip"] esxi_dns_hostname = dns_resolver(ip) usr = utils.b64_decrypt(config["usr"]) pwd = utils.b64_decrypt(config["passwd"]) return {"server_ip": ip, "server_dns_name": esxi_dns_hostname, "user_name": usr, "user_password": pwd}
def test_util_convert(self): utils=util.Util(logger=None) expected=0 for i in range(len(utils.button_list)): for j in range(len(utils.y_list)): for k in range(len(utils.x_list)): result = ( utils.convert_attack(utils.x_list[k],utils.y_list[j],utils.button_list[i])) self.assertEqual(result, expected) expected+=1
def test_preprocess_rows_size(self): utils=util.Util(logger=None) reward_row=self.create_fake_row() reward_row["AI_Stock_Change"]=-1 rows = [self.create_fake_row(),self.create_fake_row(),self.create_fake_row(),reward_row] Y_train,X_train,action_train=utils.preprocess_rows(rows) self.assertEqual(3,len(Y_train)) self.assertEqual(Y_train[0],-.99**2) self.assertEqual(Y_train[1],-.99) self.assertEqual(Y_train[2],-1) self.assertEqual(len(X_train[0]),17)
def test_util_unconvert(self): utils=util.Util(logger=None) x_cord,y_cord,button_choice=utils.unconvert_attack(4) self.assertEqual(x_cord,1) self.assertEqual(y_cord,0) self.assertEqual(button_choice,None) x_cord,y_cord,button_choice=utils.unconvert_attack(5) self.assertEqual(x_cord,0) self.assertEqual(y_cord,.25) self.assertEqual(button_choice,None) x_cord,y_cord,button_choice=utils.unconvert_attack(26) self.assertEqual(x_cord,.25) self.assertEqual(y_cord,0) self.assertEqual(button_choice,melee.Button.BUTTON_B)
def setUp(self): desired_caps = {} desired_caps['platformName'] = 'Android' desired_caps['platformVersion'] = Result["Androidversion"] desired_caps['deviceName'] = Result["SerialNo"] desired_caps['appPackage'] = el.Package['appPackage'] desired_caps['appActivity'] = el.Package['appActivity'] self.driver = webdriver.Remote('http://localhost:4723/wd/hub', desired_caps) self.pgutil = ul.Util( self.driver, parentFolder + "/screenshots/" + str(time.strftime("%Y%m%d"))) self.pgmodule = module.Module( self.driver, parentFolder + "/screenshots/" + str(time.strftime("%Y%m%d")))
def geth(self,dfi)-> pandas.DataFrame: # print(len(dfi)) dfi = dfi.reindex(index=dfi.index[::-1]) dfh = pandas.DataFrame(columns=["t1", "open", "high", "low", "close"]) # print(dfi.iloc[0]['t1']) # print(dfi.iloc[251]['t1']) lenn = len(dfi)-1 if (float(dfi.iloc[0]['t1']) == float(dfi.iloc[lenn]['t1']+lenn*300000)): # print("data is approved") ut = util.Util() over = ut.get_5min_order(dfi.iloc[0]['t1']) # print(over) ind=int(over) # print(dfi.loc[ind]) i=0 j=i+20 ii=0 while i<j: # bla bla dfh.at[ii, 't1'] = dfi.iloc[i*12+ind]['t1'] dfh.at[ii, 'open'] = dfi.iloc[i * 12+11+ind]['open'] dfh.at[ii, 'close'] = dfi.iloc[i * 12+ind]['close'] dfh.at[ii, 'high'] = max([dfi.iloc[i * 12+0+ind]['high'], dfi.iloc[i * 12+1+ind]['high'], dfi.iloc[i * 12+2+ind]['high'], dfi.iloc[i * 12+3+ind]['high'], dfi.iloc[i * 12+4+ind]['high'], dfi.iloc[i * 12+5+ind]['high'], dfi.iloc[i * 12+6+ind]['high'], dfi.iloc[i * 12+7+ind]['high'], dfi.iloc[i * 12+8+ind]['high'], dfi.iloc[i * 12+9+ind]['high'], dfi.iloc[i * 12+10+ind]['high'], dfi.iloc[i * 12+11+ind]['high']]) dfh.at[ii, 'low'] = min([dfi.iloc[i * 12 + 0+ind]['low'], dfi.iloc[i * 12 + 1+ind]['low'], dfi.iloc[i * 12 + 2+ind]['low'], dfi.iloc[i * 12 + 3+ind]['low'], dfi.iloc[i * 12 + 4+ind]['low'], dfi.iloc[i * 12 + 5+ind]['low'], dfi.iloc[i * 12 + 6+ind]['low'], dfi.iloc[i * 12 + 7+ind]['low'], dfi.iloc[i * 12 + 8+ind]['low'], dfi.iloc[i * 12 + 9+ind]['low'], dfi.iloc[i * 12 + 10+ind]['low'], dfi.iloc[i * 12 + 11+ind]['low']]) i += 1 ii+=1 dfh = dfh.reindex(index=dfh.index[::-1]) # print (dfh) else: print("data corrupt for : ", dfi) return dfh
def main(): parser = argparse.ArgumentParser() parser.add_argument("-t", action="store", dest="t_p", type=str, help="Test path") parser.add_argument("-f", action="store_true", dest="f_d", default=False, help="Force detection") args = vars(parser.parse_args()) test_path = args["t_p"] if test_path == "": print("No test path given!") return kpt_file_path = os.path.join(test_path, "kpt.txt") kpt_file_exists = os.path.isfile(kpt_file_path) force_detection = args["f_d"] img_format = "jpeg" ut = util.Util(test_path, roi=300, image_format=img_format) if not kpt_file_exists or force_detection: ut.processImage() demo.PRNet(test_path) shutil.rmtree(os.path.join(test_path, "temp")) ut.readKPT() head_pose = pose.Pose(test_path) head_pose.regress(curve=3)
def run(training, threshold, model_arg, model_save=False, **kwargs): """ Main function used to process data, create models and output predictions :param training: Boolean, if the model is being trained or being used to test output :param threshold: Threshold to be used for regression to classification predictions :param model_arg: Path to a pre-trained model :param model_save: Boolean to save trained model(s) :return: """ data_man = util.Util(FILES) file_path = os.path.realpath(__file__) script_dir = os.path.dirname(file_path) root_dir = os.path.dirname(script_dir) os.chdir(root_dir) data_dir = os.path.join(root_dir, "Data") tmp_dir = os.path.join(root_dir, "tmp") if os.path.exists(tmp_dir): shutil.rmtree(tmp_dir) os.makedirs(tmp_dir) trained_model = False try: model_class = data_man.get_model_from_string(model_arg) model_class = model_class( training=training) # Instantiate the class instance model = ( model_class.build() ) # Construct the model -> can extend to specify params here, if desired except AttributeError: print(f"Loading model: {model_arg}") model = data_man.load_model_from_path(os.path.join( data_dir, model_arg)) print("Loaded model") if type(model) is dict: model_class = data_man.get_multi_model_class() model_class = model_class(training=training, is_base=True) else: model_class = data_man.get_base_model_class() model_class = model_class( training=training) # Instantiate the base model class trained_model = True # Getting the data upfront training_file = data_man.copy_file(data_dir, "training", tmp_dir) training_data = data_man.get_data(training_file) test_file = data_man.copy_file(data_dir, "test", tmp_dir) test_data = data_man.get_data(test_file) # Need to get stats for target encoder on test data x, y, stats = model_class.process_training( training_data, is_training=True, is_regression=model_class.regression, other_df=test_data, ) if not trained_model: if training: x_train, x_val, y_train, y_val = model_class.ready_training(x, y) # Testing SMOTE, a data reducing function for imbalanced datasets if not model_class.regression: x_train, y_train = model_class.resample_train_data( x_train, y_train, **kwargs) else: if not model_class.regression: x, y = model_class.resample_train_data(x, y, **kwargs) # Use training data if training: model = model_class.train(model, x_train, y=y_train) else: model = model_class.train(model, x, y=y) # Save the trained model if model_save: os.chdir(data_dir) data_man.model_save(model, model_class.name) os.chdir(tmp_dir) if training: if trained_model: y_pred = model_class.predict(model, x, is_training=training) model_class.model_stats(y, y_pred, model_class.regression) else: y_val_pred = model_class.predict(model, x_val, is_training=training) model_class.model_stats(y_val, y_val_pred, regression=model_class.regression) else: # Output test predictions stats.update({ "other_df": training_data }) # Could pass in as another arg, but this is more fun... x_test, stats = model_class.process_testing(test_data, stats) y_test_pred = model_class.predict(model, x_test, is_training=training) if model_class.regression: y_test_pred = data_man.regression_threshold(y_test_pred, threshold) data_man.write_predictions(test_data, y_test_pred.astype(int), test_file, data_dir, tmp_dir) os.chdir(script_dir)
import util, transform ut = util.Util() tr = transform.Transform() class Marching_Cubes_2d(): def check_threshold(self, pts4, threshold): pts4_tf = [] count = 0 for i in range(4): if pts4[i] < threshold: pts4_tf.append(0) else: pts4_tf.append(1) count += 1 return pts4_tf, count def line_one(self, p0, p1, p3): vector_s = tr.vector_amp(tr.vector_2pt(p0, p1), 0.5) vector_e = tr.vector_amp(tr.vector_2pt(p0, p3), 0.5) point_s = tr.point_move(p0, vector_s) point_e = tr.point_move(p0, vector_e) return [point_s, point_e]
import json import time import util import hashlib import pymongo from lib import mongo from flask.ext.cors import CORS from flask import Flask, request from bson.objectid import ObjectId from flask.ext.socketio import SocketIO, emit, send app = Flask(__name__) CORS(app) app.config['SECRET_KEY'] = "Hardcoded Temporary Key" socketio = SocketIO(app) util = util.Util() @app.route('/') def index(): return "index" # Registers a new user and logs them in @app.route("/register", methods=['POST']) def register(): user = request.form['user'] passw = request.form['passw'] if "details" in request.form: details = request.form['details'] details = json.loads(details) else: details = False
def __init__(self, mDevice, dir): self.driver = mDevice self.util = util.Util(self.driver, dir)
config = ConfigParser.ConfigParser() config.read(config_file) if isinstance(config_tags, list): config_data = {k: config.get(section, k) for k in config_tags} else: config_data = {config_tags: config.get(section, config_tags)} return config_data if __name__ == "__main__": # Init github client creds = get_from_config(configFile, "gh_client", ["username", "oauth_token"]) ghc = ghhelper.GithubClient(credentials=creds, ignoring_errors=True) util = util.Util(ghc) outputDir = util.commentsDir print "Loading Travis data..." td = util.load_travis_data(util.filteredTravisData) projectNames = td["gh_project_name"] projectNames = projectNames.drop_duplicates() projectNames = projectNames.sort_values() startTime = time.time() print "Fetching comments..." index = 0 for label, prj in projectNames.iteritems():
def __init__(self, un, ps): self.username = un self.password = ps self.util = util.Util() self.util.log_in(un, ps)
#-*- coding: utf-8 -*- import tensorflow as tf import perceptron as nn import util as u #for i in range(1, 10): n = nn.Perceptron(4, 81, 81) n.load('./testsave/save.ckpt') util = u.Util() data_sample = util.load_data('../tmp/h-4v4') result = n.execute(data_sample) print result print len(result)
def __init__(self, folder): ''' Calculates the roll, pitch yaw based on facial keypoints. Angles are calculate based on slope of the line between two keypoints chosen. Chosen Keypoints: Roll : outside points of the eyes Pitch : point on jaw on either side Yaw: point on the lip and point lying on the center of the line passing through two points used for pitch Results saved into pose.txt file ''' self.folder = folder ut = util.Util() keypoints = np.loadtxt(os.path.join(self.folder, "kp.txt")) pose = np.array([]).reshape(-1, 3) for k in range(keypoints.shape[1] // 3): kp = keypoints[:, k * 3:k * 3 + 3] ## ROll eye0 = kp[36] eye1 = kp[45] if eye0[0] == 1000: ## If no keypoints euler = np.array([1000., 1000., 1000.]).reshape(-1, 3) pose = np.vstack([pose, euler]) continue points = np.array([eye0, eye1]) eyeCenter = ut.getCenter(points) kp_roll = kp - eyeCenter eye0 = kp_roll[36] eye1 = kp_roll[45] points = np.array([eye0, eye1]) eyeDist = ut.getDist(points, type_="roll") x = eyeDist / 2 eye0_x = x * (abs(eye0[0]) / eye0[0]) eye0_y = eye0[1] eye0_z = 0. eye1_x = x * (abs(eye1[0]) / eye1[0]) eye1_y = eye1[1] eye1_z = 0. eye0 = np.array([eye0_x, eye0_y, eye0_z]) eye1 = np.array([eye1_x, eye1_y, eye1_z]) roll = ut.getAngle(eye0, type_="roll") ## YAW jaw0 = kp[3] jaw1 = kp[13] points = np.array([jaw0, jaw1]) jawCenter = ut.getCenter(points) kp_yaw = kp - jawCenter jaw0 = kp_yaw[3] jaw1 = kp_yaw[13] points = np.array([jaw0, jaw1]) jawDist = ut.getDist(points, type_="yaw") x = jawDist / 2 jaw0_x = x * (abs(jaw0[0]) / jaw0[0]) jaw0_y = 0. jaw0_z = jaw0[2] jaw1_x = x * (abs(jaw1[0]) / jaw1[0]) jaw1_y = 0. jaw1_z = jaw1[2] jaw0 = np.array([jaw0_x, jaw0_y, jaw0_z]) jaw1 = np.array([jaw1_x, jaw1_y, jaw1_z]) yaw = ut.getAngle(jaw0, type_="yaw") yaw = yaw * -1 ## PITCH jaw0 = kp[3] jaw1 = kp[13] points = np.array([jaw0, jaw1]) jawCenter = ut.getCenter(points) kp_pitch = kp - jawCenter lip = kp_pitch[62] points = np.array([[0, 0, 0], lip]) hypCenter = ut.getCenter(points) kp_pitch = kp_pitch - hypCenter lip = kp_pitch[62] jaw0 = kp_pitch[3] jaw1 = kp_pitch[13] points = np.array([jaw0, jaw1]) jawCenter = ut.getCenter(points) points = np.array([lip, jawCenter]) hypDist = ut.getDist(points, type_="pitch") z = hypDist / 2 lip_x = 0. lip_y = lip[1] lip_z = z * (abs(lip[2]) / lip[2]) jawCenter_x = 0. jawCenter_y = jawCenter[1] jawCenter_z = z * (abs(jawCenter[2]) / jawCenter[2]) lip = np.array([lip_x, lip_y, lip_z]) jawCenter = np.array([jawCenter_x, jawCenter_y, jawCenter_z]) pitch = ut.getAngle(lip, type_="pitch") euler = np.array([roll, pitch, yaw]).reshape(-1, 3) pose = np.vstack([pose, euler]) np.savetxt(os.path.join(self.folder, "pose.txt"), pose)
return json.dumps({ "status": False, "message": "That is not a valid problem identifier!" }) if request.method == "POST": return json.dumps({ "status": False, "message": "Manual overrides not implemented yet" }) @app.route("/api/supervise/kill/<team>/<problem>/<run>") @flaskutils.requires_auth # See note on supervise_override def supervise_kill(team, problem, run): """kill a malfunctioning run""" # I have no idea how this should be implemented. return json.dumps({ "status": False, "message": "Action is not implemented yet." }) if __name__ == "__main__": logging.basicConfig(level=logging.DEBUG) if len(sys.argv) == 2 and os.path.isdir( sys.argv[1]): # overriding data directory dataDir = sys.argv[1] util = util.Util(dataDir) app.run(host='0.0.0.0')
# dolphin will hang waiting for input and never receive it controller1.connect() controller2.connect() supportedcharacters = [melee.enums.Character.PEACH, melee.enums.Character.CPTFALCON, melee.enums.Character.FALCO, \ melee.enums.Character.FOX, melee.enums.Character.SAMUS, melee.enums.Character.ZELDA, melee.enums.Character.SHEIK, \ melee.enums.Character.PIKACHU, melee.enums.Character.JIGGLYPUFF, melee.enums.Character.MARTH] cpu_state = menuhelper.CpuState.UNSET cpu_char_state = menuhelper.CpuState.UNSET is_ai = True is_ai_2 = False if is_ai: util1 = util.Util( dolphin.logger, controller1, config.Config('current_model', args.new, config.ModelType.BINARY)) if is_ai_2: util2 = util.Util( dolphin.logger, controller2, config.Config('model3', args.new, config.ModelType.BINARY)) if is_ai == True and is_ai_2 == True: score1, score2 = 0, 0 data_frame = 0 total_data_frames = 0 episode_size = 1000 buffer = experience_replay.ExperienceReplay(episode_size * 10) #Main loop
def __init__(self) -> None: self.install = False self.updated_files: Set[str] = set([]) self.util = util.Util()
#!/usr/bin/python # coding:utf-8 from uiautomatorplug.android import device as d import unittest import commands import string import time import sys import util u = util.Util() PACKAGE_NAME = 'com.intel.android.gallery3d' ACTIVITY_NAME = PACKAGE_NAME + '/.app.Gallery' #Max X position XMAX = 720 #Y postion for suboption when edit picture YSUB = 980 #Per line items' count ITEMCOUNT = 5 #Width for each item XUNIT = XMAX / ITEMCOUNT #X postion for the center of the first item XITEM = XUNIT / 2 class GalleryTest(unittest.TestCase): def setUp(self): super(GalleryTest, self).setUp()
def main(): mail_notification = False c_wmi = wmi_class.WmiClass() ssh = ssh_client.SshClient() utils = util.Util() webservers_file_path = "webserver.txt" f_nam = "srv.txt" output_file_name = "another-name.html" hosts = [] webserver_hosts = [] config = load_config("config.json") # WMI user/pass wmi_user = utils.b64_decrypt(config.get("wmi").get("user")) wmi_pwd = utils.b64_decrypt(config.get("wmi").get("password")) ssh_user = utils.b64_decrypt(config.get("ssh").get("user")) ssh_pwd = utils.b64_decrypt(config.get("ssh").get("password")) ssh_port = config.get("ssh").get("port") ssh_payload = utils.b64_decrypt(config.get("ssh").get("payload")) print("[+] Payload length:: " + str(len(ssh_payload))) user = config.get("mail").get("smtp").get("user") serv = config.get("mail").get("smtp").get("server") port = config.get("mail").get("smtp").get("port") para = config.get("mail").get("to") subject = config.get("mail").get("subject") p = _parser.Parser() # with open("C:\\Users\\opensylar\\Desktop\\mem_parse.log", "r") as fp: # l = fp.read() # p.parse_mem(l) with open(webservers_file_path, "r") as f: ports = [80, 443] for c_addr in f: c_addr = c_addr.replace("\n", "") c_addr = c_addr.replace("\r", "") print("[+] Sending web tests to " + c_addr) status_web = check_web(c_addr, ports) webserver_hosts.append(status_web) with open(f_nam, "r") as f: for c_addr in f: c_addr = c_addr.replace("\n", "") c_addr = c_addr.replace("\r", "") if is_ip_range(c_addr) > 0x0: net1 = ip_network(c_addr, strict=False) for addr in net1: addr = str(addr) hosts.append({"hostname": addr}) else: hosts.append({"hostname": c_addr}) # Setea las variables del dict for h in hosts: print("\r\n[+] Checking " + h.get("hostname")) std_out, std_error = run_ping2(h.get("hostname")) ping_vals = parse_output_ping(std_out) h.update(ip_addr=h.get("hostname")) if ping_vals["ttl"] is not 0x0: html_path = "report-details/details-" + h.get("hostname") + ".html" h.update(status="up") # dns_nam = dns_resolver(h.get("hostname")) try: dns_nam = socket.gethostbyaddr(h.get("hostname")) dns_nam = dns_nam[0] except socket.herror: dns_nam = "Unknow" os_nam = os_detect(ping_vals["ttl"]) # print("TTL:: " + str(ping_vals["ttl"])) h.update(dns_name=dns_nam) h.update(os=os_nam) h.update(html_path=html_path) s = socket_client.SocketClient() html_rpt = html_report.HtmlReport() html_rpt.set_path("report-details") if os_nam == "Windows": print("[+] Sending WMI query..") c_wmi.send_query(h.get("hostname"), wmi_user, wmi_pwd, 0x1) c_wmi.send_query(h.get("hostname"), wmi_user, wmi_pwd, 0x2) c_wmi.send_query(h.get("hostname"), wmi_user, wmi_pwd, 0x3) c_wmi.send_query(h.get("hostname"), wmi_user, wmi_pwd, 0x4) h.update(status_agent="1") html_rpt.build(h.get("hostname"), c_wmi, html_path, False) else: h.update(status_agent="1") print("[+] Sending SSH payload..") c_ssh = ssh.send_query(h.get("hostname"), ssh_port, ssh_user, ssh_pwd, ssh_payload) html_rpt.build(h.get("hostname"), c_ssh, html_path, True) # Offline else: print("[!] " + h.get("hostname") + " offline") h.update(status_agent="0") h.update(status="down") # Dead try: dns_nam = socket.gethostbyaddr(h.get("hostname")) dns_nam = dns_nam[0] except socket.herror: dns_nam = "Unknow" except socket.gaierror: print("[!] " + h.get("hostname") + " is bad host") exit(-1) h.update(dns_name=dns_nam) h.update(os="Unknow") createhtml(output_file_name, hosts, webserver_hosts) c_path = os.getcwd() file_output = c_path + "\\reports.zip" build_zip(c_path, file_output, output_file_name) if mail_notification is True: print("[+] Sending mail to SMTP relay server") u = {"sender": user} s = {"serv": serv, "port": port} m = { "to": para, "subject": subject, "attach": file_output, "body": "Report" } send_mail(m, u, s) print("[+] Finish!")
#-*- coding: utf-8 -*- import tensorflow as tf import perceptron as nn import util as u accuracies = [] #for i in range(1, 10): n = nn.Perceptron(4, 81, 81) n.train('../tmp/h-4v4', '../tmp/a-4v4', 1) data_sample = u.Util().load_data('../tmp/h-4v4') result = n.execute(data_sample) accuracies.append(result) n.save('./testsave/save.ckpt') print accuracies
# print(stdin) str_output = ''.join(str(e) for e in stdout) str_err_output = ''.join(str(e) for e in stderr) print() return {"stdout": str_output, "stderr": str_err_output} # print(stdout) # print(stderr) repeat = False a = app.App() utils = util.Util() remote_folder = "/tmp/" ssh_port = 22 creds_b64 = a.get_creds("creds.json") usr = utils.b64_decrypt(creds_b64["ssh_user"]) pwd = utils.b64_decrypt(creds_b64["ssh_password"]) plaintext_sudo_password = utils.b64_decrypt(creds_b64["ssh_password"]) upload = True array_cmds = a.get_array_cmd("cmds.json", plaintext_sudo_password) with open("srv.txt") as fp: lines = fp.readlines() for c_line_hst in lines:
import time import spec import util if __name__ == "__main__": thespec = spec.Spec() theutil = util.Util() theutil.http_post("/tunnel/create", thespec.spec()) time.sleep(1)