def __init__(self, shell): self.options = Options() self.shell = shell self.job = self.job() self.load()
def __init__(self, shell): self.options = Options() self.shell = shell self.loader = core.loader self.load()
def test_as_json(self): expected_args = {"arg1": "val1", "arg2": "val2", "arg3": "val3"} scheduler = { 'type': 'test_type', 'autorun': 'true', 'args': expected_args } options = Options(enabled=True, scheduler=scheduler) expected_json = { 'enabled': 'True', 'children': {}, 'scheduler': scheduler } self.assertDictEqual(options.as_json(), expected_json)
def __init__(self, shell): self.options = Options() self.shell = shell self.loader = core.loader self.load()
def test_to_xml(self): expected_args = {"arg1": "val1", "arg2": "val2", "arg3": "val3"} scheduler = { 'type': 'test_type', 'autorun': 'true', 'args': expected_args } options = Options(enabled=True, scheduler=scheduler) options_xml = options.to_xml() options_derived = Options(xml=options_xml) self.assertEqual(options.enabled, options_derived.enabled) self.assertEqual(options.scheduler['type'], options_derived.scheduler['type']) self.assertEqual(options.scheduler['autorun'], options_derived.scheduler['autorun']) self.assertDictEqual(options.scheduler['args'], options_derived.scheduler['args'])
def update_workflow(playbook_name, workflow_name): if running_context.controller.is_workflow_registered( playbook_name, workflow_name): if request.get_json(): data = request.get_json() if 'scheduler' in data: enabled = data['scheduler']['enabled'] if 'enabled' in data[ 'scheduler'] else False scheduler = { 'type': data['scheduler']['type'] if 'type' in data['scheduler'] else 'cron', 'autorun': (str(data['scheduler']['autorun']).lower() if 'autorun' in data['scheduler'] else 'false'), 'args': json.loads(data['scheduler']['args']) if 'args' in data['scheduler'] else {} } running_context.controller.get_workflow(playbook_name, workflow_name).options = \ Options(scheduler=scheduler, enabled=enabled) if 'new_name' in data and data['new_name']: running_context.controller.update_workflow_name( playbook_name, workflow_name, playbook_name, data['new_name']) workflow_name = data['new_name'] workflow = running_context.controller.get_workflow( playbook_name, workflow_name) if workflow: return json.dumps({ 'workflow': { 'name': workflow_name, 'options': workflow.options.as_json() }, 'status': 'success' }) else: json.dumps({ 'status': 'error: altered workflow can no longer be located' }) else: return json.dumps({'status': 'error: invalid json'}) else: return json.dumps({'status': 'error: workflow name is not valid'})
class Plugin(object): NAME = "" DESCRIPTION = "" AUTHORS = [] def __init__(self, shell): self.options = Options() self.shell = shell self.loader = core.loader self.job = self.job() self.load() ''' called when the framework starts ''' def load(self): pass ''' called when the plugin is invoked ''' def run(self): pass ''' job type of the associated plugin ''' def job(self): pass def dispatch(self, workloads, job, checkrepeat=True, repeatzombie=''): if not repeatzombie: target = self.options.get("ZOMBIE") else: target = repeatzombie commas = [x.strip() for x in target.split(",")] splitted = [] for x in commas: s = x.split("-") if len(s) == 1: splitted.append(str(x)) else: for i in range(int(s[0]), int(s[1]) + 1): splitted.append(str(i)) self.ret_jobs = [] for server in self.shell.stagers: for session in server.sessions: if (target.lower().strip() == "all" or str(session.id) in splitted) and not session.killed: if server.stager.WORKLOAD in workloads: self.shell.print_verbose("Server: %s Sesson %s" % (server, session)) workload = workloads[server.stager.WORKLOAD] options = copy.deepcopy(self.options) j = job(self.shell, session.id, self.STATE, workload, options) self.shell.jobs.append(j) self.ret_jobs.append(j.id) if checkrepeat: if options.get("REPEAT") == "true": self.repeat(self.shell, workloads, options) def load_payload(self, id): try: for server in self.shell.stagers: if int(server.payload_id) == int(id): return server.get_payload().decode() except: pass return None def parse_ips(self, ips): import core.cidr return core.cidr.get_ips(ips) def parse_ports(self, ports): import core.cidr return core.cidr.get_ports(ports) def make_vb_array(self, name, array): ret = "dim %s(%d)\n" % (name, len(array) - 1) count = 0 for el in array: x = '%s(%d) = "%s"\n' % (name, count, str(el)) ret += x count += 1 return ret def make_js_array(self, name, array): array = ['"%s"' % item for item in array] ret = "var %s = [%s];" % (name, ", ".join(array)) return ret def random_string(self, length): return ''.join(random.SystemRandom().choice(string.ascii_letters + string.digits) for n in range(length)) def validate_shellcode(self, shellcode): if len(shellcode) % 2 != 0: return False return all(c in string.hexdigits for c in shellcode) def convert_shellcode(self, shellcode): decis = [] count = 0 for i in range(0, len(shellcode), 2): count += 1 hexa = shellcode[i:i + 2] deci = int(hexa, 16) if count % 25 == 0: decis.append(" _\\n" + str(deci)) else: decis.append(str(deci)) return ",".join(decis)
Options.PrepareFeatures = False Options.PlottingEnabled = True Options.TrainDataSize = 1 Options.TestDataSize = 0 Options.InputFeaturesPath = '' Options.OutputFeaturesPath = '' Options.PredictionSaveDirectory = '' Options.RegressionAssetName = 'NZDUSD_H4' Options.RegressionMethodName = 'HARM_TRIANGULAR' if (len(sys.argv) > 1): Options.InputFeaturesPath = sys.argv[1] if (len(sys.argv) > 2): Options.OutputFeaturesPath = sys.argv[2] print(sys.argv[1], sys.argv[2]) if (len(sys.argv) > 3): Options.RegressionAssetName = sys.argv[3] if (len(sys.argv) > 4): Options.RegressionMethodName = sys.argv[4] Options.OutputValuesKey = Options.RegressionAssetName + '_RPO' Options.OutputDateValuesKey = Options.RegressionAssetName + '_RealClose_date' Options.RealClosePricesKey = Options.RegressionAssetName + '_RealClose' Options.Init() core.run.main()
def __func(wf_name): if running_context.controller.is_workflow_registered( playbook_name, wf_name): data = request.get_json() if 'scheduler' in data: enabled = data['scheduler']['enabled'] if 'enabled' in data[ 'scheduler'] else False scheduler = { 'type': data['scheduler']['type'] if 'type' in data['scheduler'] else 'cron', 'autorun': (str(data['scheduler']['autorun']).lower() if 'autorun' in data['scheduler'] else 'false'), 'args': json.loads(data['scheduler']['args']) if 'args' in data['scheduler'] else {} } running_context.controller.get_workflow(playbook_name, wf_name).options = \ Options(scheduler=scheduler, enabled=enabled) if 'new_name' in data and data['new_name']: if running_context.controller.is_workflow_registered( playbook_name, data['new_name']): current_app.logger.warning( 'Could not update workflow {0}. Workflow already exists.' .format(workflow_name)) return { "error": "Workflow already exists." }, OBJECT_EXISTS_ERROR else: running_context.controller.update_workflow_name( playbook_name, wf_name, playbook_name, data['new_name']) running_context.Triggers.update_workflow( old_workflow=wf_name, new_workflow=data['new_name']) wf_name = data['new_name'] workflow = running_context.controller.get_workflow( playbook_name, wf_name) if workflow: returned_json = { 'workflow': { 'name': wf_name, 'options': workflow.options.as_json(), 'start': workflow.start_step } } current_app.logger.info( 'Updated workflow {0}-{1} to {2}'.format( playbook_name, wf_name, returned_json)) return returned_json, SUCCESS else: current_app.logger.error( 'Altered workflow {0}-{1} no longer in controller'.format( playbook_name, wf_name)) return { 'error': 'Altered workflow can no longer be located.' }, INVALID_INPUT_ERROR else: current_app.logger.error( 'Workflow {0}-{1} not found in controller. Cannot be updated.'. format(playbook_name, wf_name)) return { 'error': 'Playbook or workflow does not exist.' }, OBJECT_DNE_ERROR
def main(): # #FixInterruptHandling().fix() # if (Options.PrepareFeatures): dataPrepared = DataPrepare.run(Options.OutputFeaturesPath, Options.InputFeaturesPath, Options.TrainDataStartDate, Options.FuturePredictionStartDate, Options.FuturePredictionEndDate()) # output_data_dict_train, output_data_dict_future = DataReader.get_output_features( ) # input_data_dict_train, input_data_dict_future = DataReader.get_input_features( ) # Options.InputFeatureSize = len(input_data_dict_train.values()) # plotter = Plotter() #plotter.plot_date_price(date_values, price_values, Options.RegressionAssetName) wave_no = 0 input1 = list(input_data_dict_train.values())[wave_no] #plotter.plot_xy(date_values, input1, list(input_data_dict.keys())[wave_no], 'Dates', 'Power') # Construct PDS input_pds = pd.DataFrame.from_dict(input_data_dict_train) real_close_pds = pd.DataFrame( data=output_data_dict_train[Options.RealClosePricesKey]) output_pds = pd.DataFrame( data=output_data_dict_train[Options.OutputValuesKey]) date_values = output_data_dict_train[Options.OutputDateValuesKey] future_input_pds = pd.DataFrame.from_dict(input_data_dict_future) future_output_pds, future_real_close_pds, future_date_values = DataReader.get_future_output_features( output_data_dict_future) # End Construct PDS # Data Pre Processor pre_processor = DataPreProcessor() #output_pds = pre_processor.to_wavelet(output_pds) #output_pds = pre_processor.filter_by_savgol(output_pds, 51, 3) processor = DataProcessor(input_pds, output_pds, date_values, Options.TrainDataSize, Options.TestDataSize) # LAZY LOAD Neural Network lib ? from core.nnmodel import NNModel ### ONE BY ONE START if (Options.DataWindow == Options.DataWindowType.OneByOne): x_train_o, y_train_o, date_train = processor.get_one_by_one_data( 'train', seq_len=1, multiply_y_vector=Options.MultiplyDataByCustomFactor, normalise=Options.NormaliseData) x_val_o, y_val_o, date_val = processor.get_one_by_one_data( 'val', seq_len=1, multiply_y_vector=Options.MultiplyDataByCustomFactor, normalise=Options.NormaliseData) model = NNModel() model.build_one_by_one_model() callbacks = model.get_callbacks(Options.KerasOneByOneEpochs) model.fit_one_by_one(x_train_o, y_train_o, x_val_o, y_val_o, Options.KerasOneByOneBatchSize, Options.KerasOneByOneEpochs, callbacks) y_train_o_pred = model.predict(x_train_o, 'x_train_o') model.save_pred_to_csv(date_train, y_train_o_pred, Options.PredictionSaveDirs(), Options.GetPredictionSaveFileName('train')) plotter.plot_different_scale(y_train_o_pred, y_train_o, date_train, y_label1="Train Prediction", y_label2="Train") y_val_pred = model.predict(x_val_o, 'x_val_o') model.save_pred_to_csv(date_val, y_val_pred, Options.PredictionSaveDirs(), Options.GetPredictionSaveFileName('val')) plotter.plot_different_scale(y_val_pred, y_val_o, date_val, y_label1="Validation Prediction", y_label2="Validation") processor2 = DataProcessor(input_pds, real_close_pds, date_values, Options.TrainDataSize, Options.TestDataSize) #DELETE THIS temp, y_test_real, date_real = processor2.get_one_by_one_data( 'test', seq_len=1, multiply_y_vector=Options.MultiplyDataByCustomFactor, normalise=Options.NormaliseData) #DELETE THIS x_test_o, y_test_o, date_test = processor.get_one_by_one_data( 'test', seq_len=1, multiply_y_vector=Options.MultiplyDataByCustomFactor, normalise=Options.NormaliseData) y_test_o_pred = model.predict(x_test_o, 'x_test_o') model.save_pred_to_csv(date_test, y_test_o_pred, Options.PredictionSaveDirs(), Options.GetPredictionSaveFileName('test')) plotter.plot_different_scale(y_test_o_pred, y_test_real, y_label1="Test Prediction", y_label2="Real") plotter.plot_different_scale(y_test_o_pred, y_test_o, date_real, y_label1="Test Prediction", y_label2="Real RPO") future_pred = model.predict(future_input_pds, 'future_input_pds') plotter.plot_different_scale( future_pred, future_real_close_pds, np.array([]), y_label1="Future Prediction", y_label2="Future Real") #np.array(future_date_values) throws ex model.save_pred_to_csv(np.array(future_date_values), future_pred, Options.PredictionSaveDirs(), Options.GetPredictionSaveFileName('future')) ### ONE BY ONE END if (Options.DataWindow == Options.DataWindowType.OneByOneTelosSearch): from core.nntelossearch import NNTelosSearch telosSearch = NNTelosSearch() x_train_o, y_train_o = processor.get_train_data_OBO( seq_len=1, normalise=Options.NormaliseData) telosSearch.minimize(x_train_o, y_train_o, [], []) #TELOS END if (Options.DataWindow == Options.DataWindowType.WindowBatch): #x_train, y_train = processor.get_train_data(seq_len=Options.WindowSequenceLength, normalise = Options.NormaliseData) #y_train = y_train * Options.MultiplyDataByCustomFactor #x_test, y_test = processor.get_test_data(seq_len = Options.WindowSequenceLength, normalise = Options.NormaliseData) #y_test = y_test * Options.MultiplyDataByCustomFactor model = NNModel() model.build_windowed_batch_model() callbacks = model.get_callbacks(Options.KerasWindowedEpochs) x_train, y_train, date_train = processor.get_window_train_data( arr_type='train', seq_len=Options.WindowSequenceLength, step=Options.WindowShiftStep, feature_len=Options.InputFeatureSize, multiply_y_vector=1) x_val, y_val, date_val = processor.get_window_train_data( arr_type='val', seq_len=Options.WindowSequenceLength, step=Options.WindowShiftStep, feature_len=Options.InputFeatureSize, multiply_y_vector=1) x_test, y_test, date_test = processor.get_window_train_data( arr_type='test', seq_len=Options.WindowSequenceLength, step=Options.WindowShiftStep, feature_len=Options.InputFeatureSize, multiply_y_vector=1) if (Options.FlattenWindowVector): x_train = np.asarray(x_train, dtype=np.float32).reshape( -1, Options.WindowSequenceLength * Options.InputFeatureSize) x_val = np.asarray(x_val, dtype=np.float32).reshape( -1, Options.WindowSequenceLength * Options.InputFeatureSize) x_test = np.asarray(x_test, dtype=np.float32).reshape( -1, Options.WindowSequenceLength * Options.InputFeatureSize) model.fit_one_by_one(x_train, y_train, x_val, y_val, Options.KerasWindowedBatchSize, Options.KerasWindowedEpochs, callbacks) if (Options.FlattenWindowVector): plotter.plot_different_scale(model.predict(x_train, 'x_train'), y_train, date_train, y_label1="Train Prediction", y_label2="Train") plotter.plot_different_scale(model.predict(x_val, 'x_val'), y_val, date_val, y_label1="Validation Prediction", y_label2="Validation") plotter.plot_different_scale(model.predict(x_test, 'x_test'), y_test, date_test, y_label1="Test Prediction", y_label2="Test") else: train_pred_point_by_point = model.predict_point_by_point(x_train) plotter.plot_different_scale(train_pred_point_by_point, y_train, date_train, y_label1="Train Prediction", y_label2="Train") test_pred_point_by_point = model.predict_point_by_point(x_test) plotter.plot_different_scale(test_pred_point_by_point, y_test, date_test, y_label1="Test Prediction", y_label2="Real") #WINDOW_END print("THE_END")
class Plugin(object): NAME = "" DESCRIPTION = "" AUTHORS = [] def __init__(self, shell): self.options = Options() self.shell = shell self.loader = core.loader self.load() ''' called when the framework starts ''' def load(self): pass ''' called when the plugin is invoked ''' def run(self): pass def dispatch(self, workloads, job): target = self.options.get("ZOMBIE") commas = [x.strip() for x in target.split(",")] splitted = [] for x in commas: s = x.split("-") if len(s) == 1: splitted.append(int(x)) else: splitted.extend(range(int(s[0]), int(s[1]) + 1)) for server in self.shell.stagers: for session in server.sessions: if target == "ALL" or int(session.id) in splitted: if server.stager.WORKLOAD in workloads.keys(): workload = workloads[server.stager.WORKLOAD] options = copy.deepcopy(self.options) j = job(self.shell, session, self.shell.state, workload, options) session.jobs.append(j) def load_payload(self, id): try: for server in self.shell.stagers: if int(server.payload_id) == int(id): return server.get_payload().decode() except: pass return None def parse_ips(self, ips): import core.cidr return core.cidr.get_ips(ips) def parse_ports(self, ports): import core.cidr return core.cidr.get_ports(ports) def make_vb_array(self, name, array): ret = "dim %s(%d)\n" % (name, len(array) - 1) count = 0 for el in array: x = '%s(%d) = "%s"\n' % (name, count, str(el)) ret += x count += 1 return ret def make_js_array(self, name, array): array = ['"%s"' % item for item in array] ret = "var %s = [%s];" % (name, ", ".join(array)) return ret def random_string(self, length): return ''.join(random.SystemRandom().choice(string.ascii_letters + string.digits) for n in range(length)) def validate_shellcode(self, shellcode): if len(shellcode) % 2 != 0: return False return all(c in string.hexdigits for c in shellcode) def convert_shellcode(self, shellcode): decis = [] count = 0 for i in range(0, len(shellcode), 2): count += 1 hexa = shellcode[i:i + 2] deci = int(hexa, 16) if count % 25 == 0: decis.append(" _\\n" + str(deci)) else: decis.append(str(deci)) return ",".join(decis)
class Plugin(object): NAME = "" DESCRIPTION = "" AUTHORS = [] def __init__(self, shell): self.options = Options() self.shell = shell self.loader = core.loader self.load() ''' called when the framework starts ''' def load(self): pass ''' called when the plugin is invoked ''' def run(self): pass def dispatch(self, workloads, job): target = self.options.get("ZOMBIE") splitted = [x.strip() for x in target.split(",")] for server in self.shell.stagers: for session in server.sessions: if target == "ALL" or str(session.id) in splitted: if server.stager.WORKLOAD in workloads.keys(): workload = workloads[server.stager.WORKLOAD] options = copy.deepcopy(self.options) j = job(self.shell, session, self.shell.state, workload, options) session.jobs.append(j) def load_payload(self, id): try: for server in self.shell.stagers: if int(server.payload_id) == int(id): return server.get_payload().decode() except: pass return None def parse_ips(self, ips): import core.cidr return core.cidr.get_ips(ips) def parse_ports(self, ports): import core.cidr return core.cidr.get_ports(ports) def make_vb_array(self, name, array): ret = "dim %s(%d)\n" % (name, len(array) - 1) count = 0 for el in array: x = '%s(%d) = "%s"\n' % (name, count, str(el)) ret += x count += 1 return ret def make_js_array(self, name, array): array = ['"%s"' % item for item in array] ret = "var %s = [%s];" % (name, ", ".join(array)) return ret def random_string(self, length): return ''.join(random.SystemRandom().choice(string.ascii_letters + string.digits) for n in range(length)) def validate_shellcode(self, shellcode): if len(shellcode) % 2 != 0: return False return all(c in string.hexdigits for c in shellcode) def convert_shellcode(self, shellcode): decis = [] count = 0 for i in range(0, len(shellcode), 2): count += 1 hexa = shellcode[i:i+2] deci = int(hexa, 16) if count % 25 == 0: decis.append(" _\\n" + str(deci)) else: decis.append(str(deci)) return ",".join(decis)
def workflow(playbook_name, workflow_name, action): if action == 'add': form = forms.AddWorkflowForm(request.form) if form.validate(): status = 'success' template_playbook = form.playbook.data template = form.template.data if template and template_playbook: if template_playbook in [ os.path.splitext(workflow)[0] for workflow in locate_workflows_in_directory(config.templatesPath) ]: res = running_context.controller.create_workflow_from_template( playbook_name=playbook_name, workflow_name=workflow_name, template_playbook=template_playbook, template_name=template) if not res: add_default_template(playbook_name, workflow_name) status = 'warning: template not found in playbook. Using default template' else: add_default_template(playbook_name, workflow_name) status = 'warning: template playbook not found. Using default template' else: add_default_template(playbook_name, workflow_name) if running_context.controller.is_workflow_registered( playbook_name, workflow_name): workflow = running_context.controller.get_workflow( playbook_name, workflow_name) return json.dumps({ 'workflow': { 'name': workflow_name, 'steps': workflow.get_cytoscape_data(), 'options': workflow.options.as_json() }, 'status': status }) else: return json.dumps({'status': 'error: could not add workflow'}) else: return json.dumps({'status': 'error: invalid form'}) elif action == 'edit': if running_context.controller.is_workflow_registered( playbook_name, workflow_name): form = forms.EditPlayNameForm(request.form) if form.validate(): enabled = form.enabled.data if form.enabled.data else False scheduler = { 'type': form.scheduler_type.data if form.scheduler_type.data else 'chron', 'autorun': str(form.autoRun.data).lower() if form.autoRun.data else 'false', 'args': json.loads(form.scheduler_args.data) if form.scheduler_args.data else {} } running_context.controller.get_workflow(playbook_name, workflow_name).options = \ Options(scheduler=scheduler, enabled=enabled) if form.new_name.data: running_context.controller.update_workflow_name( playbook_name, workflow_name, playbook_name, form.new_name.data) workflow_name = form.new_name.data workflow = running_context.controller.get_workflow( playbook_name, workflow_name) if workflow: return json.dumps({ 'workflow': { 'name': workflow_name, 'options': workflow.options.as_json() }, 'status': 'success' }) else: json.dumps({ 'status': 'error: altered workflow can no longer be located' }) else: return json.dumps({'status': 'error: invalid form'}) else: return json.dumps({'status': 'error: workflow name is not valid'}) elif action == 'save': if running_context.controller.is_workflow_registered( playbook_name, workflow_name): if request.get_json(): if 'cytoscape' in request.get_json(): workflow = running_context.controller.get_workflow( playbook_name, workflow_name) workflow.from_cytoscape_data( json.loads(request.get_json()['cytoscape'])) try: write_format = 'w' if sys.version_info[0] == 2 else 'wb' workflow_filename = os.path.join( config.workflowsPath, '{0}.workflow'.format(playbook_name)) with open(workflow_filename, write_format) as workflow_out: xml = ElementTree.tostring( running_context.controller.playbook_to_xml( playbook_name)) workflow_out.write(xml) return json.dumps({ "status": "success", "steps": workflow.get_cytoscape_data() }) except (OSError, IOError) as e: return json.dumps({ "status": "Error saving: {0}".format(e.message), "steps": workflow.get_cytoscape_data() }) else: return json.dumps({"status": "error: malformed json"}) else: return json.dumps({"status": "error: no information received"}) else: return json.dumps({'status': 'error: workflow name is not valid'}) elif action == 'delete': if running_context.controller.is_workflow_registered( playbook_name, workflow_name): running_context.controller.removeWorkflow(playbook_name, workflow_name) status = 'success' else: status = 'error: invalid workflow name' return json.dumps({ "status": status, "playbooks": running_context.controller.get_all_workflows() }) elif action == 'execute': if running_context.controller.is_workflow_registered( playbook_name, workflow_name): running_context.controller.executeWorkflow(playbook_name, workflow_name) status = 'success' else: status = 'error: invalid workflow name' return json.dumps({"status": status}) else: return json.dumps({"status": 'error: invalid operation'})