def collect(self): filename = "network_config.txt" filePath = self.collectionPath + filename f = open(filePath, "w+") f.write("en0\n-----------------------------\n") output = os.popen("ifconfig en0").read().rstrip() f.write(output + "\n\n") f.write("en1\n-----------------------------\n") output = os.popen("ifconfig en1").read().rstrip() f.write(output + "\n\n") # Output will already have a "DNS configuration" heading, no need to add one output = os.popen("scutil --dns 2>&1").read().rstrip() f.write(output + "\n\n") f.write("Proxies\n-----------------------------\n") output = os.popen("scutil --proxy 2>&1").read().rstrip() f.write(output + "\n\n") f.write("pf rules\n-----------------------------\n") output = os.popen("sudo pfctl -s rules 2>&1").read().rstrip() f.write(output + "\n\n") f.close self.pathsToCollect.append("/etc/hosts") Collector.collect(self)
def collect(self): self.pathsToCollect.append("/etc/profile") self.pathsToCollect.append("/etc/bashrc") self.pathsToCollect.append("/etc/sudoers") for user in self.userList: p = "/Users/{0}/.bash_profile".format(user) if os.path.isfile(p): self.pathsToCollect.append(p) p = "/Users/{0}/.bash_login".format(user) if os.path.isfile(p): self.pathsToCollect.append(p) p = "/Users/{0}/.profile".format(user) if os.path.isfile(p): self.pathsToCollect.append(p) p = "/Users/{0}/.bash_logout".format(user) if os.path.isfile(p): self.pathsToCollect.append(p) Collector.collect(self)
def CFagent(defaults): env = Game(**defaults) mover = Mover(env, _extra_dim=1, **defaults) teleporter = Teleporter(env, **defaults) buffer = ReplayBuffer(**defaults) CFagent = CFAgent(env, **defaults) CFbuffer = CFReplayBuffer(**defaults) collector = Collector(**defaults) with Save(env, collector, mover, teleporter, CFagent, **defaults) as save: intervention_idx, modified_board = teleporter.pre_process(env) dones = CFagent.pre_process(env) CF_dones, cfs = None, None for frame in loop(env, collector, save, teleporter): CFagent.counterfact(env, dones, teleporter, CF_dones, cfs) modified_board = teleporter.interveen(env.board, intervention_idx, modified_board) actions = mover(modified_board) observations, rewards, dones, info = env.step(actions) modified_board, modified_rewards, modified_dones, teleport_rewards, intervention_idx = teleporter.modify(observations, rewards, dones, info) buffer.teleporter_save_data(teleporter.boards, observations, teleporter.interventions, teleport_rewards, dones, intervention_idx) mover.learn(modified_board, actions, modified_rewards, modified_dones) board_before, board_after, intervention, tele_rewards, tele_dones = buffer.sample_data() teleporter.learn(board_after, intervention, tele_rewards, tele_dones, board_before) collector.collect([rewards, modified_rewards, teleport_rewards], [dones, modified_dones]) CF_dones, cfs = CFagent.counterfact_check(dones, env, **defaults) CFbuffer.CF_save_data(CFagent.boards, observations, CFagent.counterfactuals, rewards, dones, CF_dones) CFboard, CFobs, cf, CFrewards, CFdones1 = CFbuffer.sample_data() CFagent.learn(CFobs, cf, CFrewards, CFdones1, CFboard)
def collect(self): filename = "processes.txt" filePath = self.collectionPath + filename f = open(filePath, "w+") f.write("Processes\n-----------------------------\n") processData = os.popen( "ps axo user,pid,ppid,start,time,command").read().rstrip() f.write(processData + "\n\n") f.close filename = "processes_files.txt" filePath = self.collectionPath + filename f = open(filePath, "w+") f.write("Files open by process\n-----------------------------\n") output = os.popen("lsof").read().rstrip() f.write(output + "\n\n") f.close filename = "processes_network.txt" filePath = self.collectionPath + filename f = open(filePath, "w+") f.write( "Network connections open by process\n-----------------------------\n" ) output = os.popen("lsof -i").read().rstrip() f.write(output + "\n\n") f.close # No file paths to collect Collector.collect(self)
def metateleport(defaults): collector = Collector(**defaults) env = Game(**defaults) mover = Mover(env, _extra_dim=1, **defaults) teleporter1 = Teleporter(env, _extra_dim=1, **defaults) teleporter2 = MetaTeleporter(env, **defaults) buffer1 = ReplayBuffer(**defaults) buffer2 = ReplayBuffer(**defaults) with Save(env, collector, mover, teleporter1, teleporter2, **defaults) as save: intervention_idx2, modified_board2 = teleporter2.pre_process(env) intervention_idx1, _ = teleporter1.pre_process(env) for frame in loop(env, collector, save, teleporter1, teleporter2): modified_board2 = teleporter2.interveen(env.board, intervention_idx2, modified_board2) modified_board1 = teleporter1.interveen(env.board, intervention_idx1, modified_board2) actions = mover(modified_board1) observations, rewards, dones, info = env.step(actions) modified_board1, modified_board2, modified_rewards1, modified_rewards2, modified_dones1, modified_dones2, tele_rewards, intervention_idx1, intervention_idx2 = teleporter2.metamodify(observations, rewards, dones, info, teleporter1.interventions) buffer1.teleporter_save_data(teleporter1.boards, modified_board2, teleporter1.interventions, modified_rewards2, modified_dones2, intervention_idx1) buffer2.teleporter_save_data(teleporter2.boards, observations, teleporter2.interventions, tele_rewards, dones, intervention_idx2) mover.learn(modified_board1, actions, modified_rewards1, modified_dones1) board_before, board_after, intervention, tel_rewards, tele_dones = buffer1.sample_data() teleporter1.learn(board_after, intervention, tel_rewards, tele_dones, board_before) board_before, board_after, intervention, tel_rewards, tele_dones = buffer2.sample_data() teleporter2.learn(board_after, intervention, tel_rewards, tele_dones, board_before) collector.collect([rewards, modified_rewards1, modified_rewards2, tele_rewards], [dones, modified_dones1, modified_dones2])
def collect(self): filename = "trusted_certificates.txt" filePath = self.collectionPath + filename f = open(filePath, "w+") f.write("Certificate trust settings\n-----------------------------\n") for user in self.userList: f.write("For user {0}:\n\n".format(user)) output = os.popen( "sudo -u {0} security dump-trust-settings 2>&1".format( user)).read().rstrip() f.write(output + "\n\n") f.write("Admin certificate info\n-----------------------------\n") output = os.popen("security dump-trust-settings -d").read().rstrip() f.write(output + "\n\n") f.write("System certificate info\n-----------------------------\n") output = os.popen("security dump-trust-settings -s").read().rstrip() f.write(output + "\n\n") f.write("All certificates\n-----------------------------\n") output = self.collectAllCerts() f.write(output) f.close # Add any paths to self.pathsToCollect Collector.collect(self)
def collect(self): filename = "history_downloads.txt" filePath = self.collectionPath + filename f = open(filePath, "w+") f.write( "Downloads (QuarantineEventsV2)\n-----------------------------\n") output = self.collectDownloads() f.write(output) f.close filename = "history_safari.txt" filePath = self.collectionPath + filename f = open(filePath, "w+") f.write("Safari history\n-----------------------------\n") output = self.collectSafari() f.write(output) f.close filename = "history_chrome.txt" filePath = self.collectionPath + filename f = open(filePath, "w+") f.write("Chrome history\n-----------------------------\n") output = self.collectChrome() f.write(output) f.close filename = "history_firefox.txt" filePath = self.collectionPath + filename f = open(filePath, "w+") f.write("Firefox history\n-----------------------------\n") output = self.collectFirefox() f.write(output) f.close Collector.collect(self)
class RankingCrawler(): # flow capacity (MB) def __init__(self, cookie, capacity=1024): self.date = START_DATE self.domain = DOMAIN self.mode = PIXIV_MODES[PIXIV_MODE] # url sample: https://www.pixiv.net/ranking.php?mode=daily&date=20200801&p=1&format=json # ref url sample: https://www.pixiv.net/ranking.php?mode=daily&date=20200801 self.url = 'https://www.pixiv.net/ranking.php?mode=' + self.mode self.cookie = cookie self.headers = {'x-requested-with': 'XMLHttpRequest'} self.collector = Collector(cookie, capacity) def __nextday(self): self.date += datetime.timedelta(days=1) # collect illust_id from daily json def collect(self): # note that 50 artworks per p=x page_num = (ARTWORKS_PER - 1) // 50 + 1 #ceil print("---start collecting " + self.mode + " ranking---") print("start with " + self.date.strftime("%Y-%m-%d")) print("end with " + (self.date + datetime.timedelta( days=self.domain - 1)).strftime("%Y-%m-%d" + '\n')) # store all jsons' url in self.group self.group = set() for _i in range(DOMAIN): for j in range(page_num): self.group.add(self.url + '&date=' + self.date.strftime("%Y%m%d") + '&p=' + str(j + 1) + '&format=json') self.__nextday() pool = ParallelPool(len(self.group)) while len(self.group) or not pool.empty(): time.sleep(THREAD_DELAY) # send ranking_json to parallel pool while not pool.full() and len(self.group): url = self.group.pop() ref = re.search('(.*)&p', url).group(1) headers = self.headers.update({'Referer': ref}) pool.add( CollectorUnit(url, self.cookie, ranking_selector, headers)) # remove complete thread finished = pool.finished_item() while True: try: ranking_json = next(finished) self.collector.add(ranking_json.group) if MOST_OUTPUT: print("--send page " + ranking_json.url + " to collector--") except StopIteration: break print("\n---collect " + self.mode + " ranking complete---") def run(self): self.collect() self.collector.collect() return self.collector.download()
def collect(self): output = "" receiptPlistPaths = glob.glob("/private/var/db/receipts/*.plist") for onePlistPath in receiptPlistPaths: if os.path.isfile(onePlistPath) and onePlistPath.endswith( ".plist"): plistDict = FoundationPlist.readPlist(onePlistPath) if not plistDict: continue output += str(plistDict["InstallDate"]) + "\t" output += plistDict["InstallPrefixPath"] + "\t" output += plistDict["InstallProcessName"] + "\t" output += plistDict["PackageFileName"] + "\t" output += plistDict["PackageIdentifier"] + "\t" output += plistDict["PackageVersion"] + "\n" output = "Install Date\tPrefix Path\tProcess Name\tFile Name\tIdentifier\tVersion\n" + "\n".join( sorted(output.split("\n"))) filename = "installs.txt" filePath = self.collectionPath + filename f = open(filePath, "w+") f.write(output) f.close self.pathsToCollect.append("/Library/Receipts/InstallHistory.plist") Collector.collect(self)
def collect(self): for user in self.userList: bashHistPath = "/Users/{0}/.bash_history".format(user) if os.path.isfile(bashHistPath): self.pathsToCollect.append(bashHistPath) Collector.collect(self)
def collect_sample(): c = Collector() while True: sample = sample_queue.get() logging.info('Processing sample {}'.format(sample.url)) try: c.collect(sample) except Exception as e: logging.info('Error processing sample: ')
def main(): conf = parse_options() c = Client(conf) collector = Collector(c) start = c.get_user(conf.start_user) collector.collect(start) g = collector.graph nx.write_dot(g, conf.output_file)
def simple(defaults): collector = Collector(**defaults) env = Game(**defaults) mover = Mover(env, **defaults) with Save(env, collector, mover, **defaults) as save: for frame in loop(env, collector, save): actions = mover(env.board) observations, rewards, dones, info = env.step(actions) mover.learn(observations, actions, rewards, dones) collector.collect([rewards], [dones])
def collect(self): filename = "persistence.txt" filePath = util.safePathJoin(self.collectionPath, filename) f = open(filePath, "w+") f.write( "PICT - Persistence information\n==============================\n\n" ) f.write("Login items (current user)\n------------------------------\n") logins = self.collectLoginItems() f.write(logins + "\n\n") f.write("Hidden login items\n------------------------------\n") logins = self.collectHiddenLoginItems() f.write(logins + "\n\n") f.write("Kernel extensions\n------------------------------\n") output = self.collectKexts() f.write(output + "\n\n") f.write("Cron jobs\n------------------------------\n") output = self.collectCronJobs() f.write(output + "\n\n") f.write("Startup items\n------------------------------\n") output = self.collectStartupItems() f.write(output + "\n\n") f.write("Login hooks\n------------------------------\n") output = self.collectLoginHooks() f.write(output + "\n\n") f.write("Launch agents\n------------------------------\n") output = self.collectLaunchAgents() f.write(output + "\n\n") f.write("Launch daemons\n------------------------------\n") output = self.collectLaunchDaemons() f.write(output + "\n\n") f.write("User launch agents\n------------------------------\n") output = self.collectUserLaunchAgents() f.write(output + "\n\n") f.write("launchctl list\n------------------------------\n") output = self.collectLaunchctlList() f.write(output + "\n\n") f.close self.collectMiscArtifacts() Collector.collect(self)
class CollectSourceTask(QObject): # 任务完成的信号 done = pyqtSignal() def __init__(self, src): super().__init__() self.src = src self.collector = Collector() @pyqtSlot() def doWork(self): self.collector.collect(self.src) self.done.emit()
def collect(self): filename = "profiles.txt" filePath = self.collectionPath + filename f = open(filePath, "w+") f.write("Installed configuration profiles\n-----------------------------\n") output = os.popen("profiles show -all").read() f.write(output) f.close # Add any paths to self.pathsToCollect Collector.collect(self)
def collect(self): filename = "blah.txt" filePath = self.collectionPath + filename f = open(filePath, "w+") f.write("Label\n-----------------------------\n") output = self.collectSomething() f.write(output + "\n\n") f.close # Add any paths to self.pathsToCollect Collector.collect(self)
def run(self): print("==== Checking hosts on ====") # Here we can block by online workers (only run if haver 4 workers), # but we can work with less then 4 workers, and in my test, I have only 1. num_hosts = self._get_hosts_on(1) print("Hosts ON: %d" % num_hosts) print("==== Creating random matrices ====") self.matrix_a = self._get_random_matrix(self.a_n, self.a_m) self.matrix_b = self._get_random_matrix(self.b_n, self.b_m) print("==== Created Matrices: ====") self._print_two_matrices(self.matrix_a, self.matrix_b) self.matrix_divide() distributor = Distributor("*", "50010") collector = Collector("*", "50012", 5000) distributor.send_jobs(self._create_jobs()) # For test, check services in rasp's self._check_services(1) results = collector.collect(4) if 'err' in results: print("Error in some RasPI: %s" % results['err']) exit() print("==== Appending matrices ====") C1 = self._matrix_sum(results['A1B1'], results['A2B2']) C2 = self._matrix_sum(results['A3B1'], results['A4B2']) C = C1 + C2 print("==== Final result: ====") self._print_matrix(C)
def collect(self): filename = "fileinfo.txt" filePath = self.collectionPath + filename f = open(filePath, "w+") f.write("{0}\t{1}\t{2}\t{3}\t{4}\t{5}\t{6}\t{7}\t{8}\r".format( "Raw Flags", "Flags", "UID", "GID", "Mode (oct)", "Created", "Modified", "Accessed", "Path")) output = self.collectFromPaths() f.write(output + "\n\n") f.close # Add any paths to self.pathsToCollect Collector.collect(self)
def main(): name, environment, hours, total_agents, done = params['name'], params['environment'], params['hours'], params['total_agents'], None agent = Agent(**params) env = Environments(render=False, envs=[environment for _ in range(total_agents)], agent=agent) collector = Collector(**params) tid, f = time() + 3600 * hours - 300, 0 while time() < tid: f += 1 obs, hn, cn = env.start() act, obs_old, h0, c0, hn, cn, before_trace, after_trace = agent.chooseMulti(obs, hn, cn, done=done) obs, rew, done, info = env.step(act, hn, cn) collector.collect(rew, done, act, agent.onpolicy) if not agent.onpolicy and f > 10: agent.rememberMulti(obs_old, act, obs, rew, h0, c0, hn, cn, done, before_trace, after_trace) agent.learn() saveAgent(agent, name) saveCollector(collector, name)
def teleport(defaults): collector = Collector(**defaults) env = Game(**defaults) mover = Mover(env, _extra_dim=1, **defaults) teleporter = Teleporter(env, **defaults) buffer = ReplayBuffer(**defaults) with Save(env, collector, mover, teleporter, **defaults) as save: intervention_idx, modified_board = teleporter.pre_process(env) for frame in loop(env, collector, save, teleporter): modified_board = teleporter.interveen(env.board, intervention_idx, modified_board) actions = mover(modified_board) observations, rewards, dones, info = env.step(actions) modified_board, modified_rewards, modified_dones, teleport_rewards, intervention_idx = teleporter.modify(observations, rewards, dones, info) buffer.teleporter_save_data(teleporter.boards, observations, teleporter.interventions, teleport_rewards, dones, intervention_idx) mover.learn(modified_board, actions, modified_rewards, modified_dones) board_before, board_after, intervention, tele_rewards, tele_dones = buffer.sample_data() teleporter.learn(board_after, intervention, tele_rewards, tele_dones, board_before) collector.collect([rewards, modified_rewards, teleport_rewards], [dones, modified_dones])
class UserCrawler(): def __init__(self, artist_id, cookie, capacity=1024): self.url = 'https://www.pixiv.net/ajax/user/' + artist_id + '/profile/all?lang=zh' self.ref = 'https://www.pixiv.net/users/' + artist_id + '/illustrations' self.headers = {'x-user-id': USER_ID} self.headers.update({'Referer': self.ref}) self.cookie = cookie self.collector = Collector(cookie, capacity) def collect(self): user = CollectorUnit(self.url, self.cookie, user_selector, self.headers) user.start() user.join() self.collector.add(user.group) print("--send user " + user.url + " to collector--") def run(self): self.collect() self.collector.collect() return self.collector.download()
def collect(self): filename = "network_config.txt" filePath = self.collectionPath + filename f = open(filePath, "w+") output = os.popen("scutil --dns 2>&1").read().rstrip() f.write(output + "\n\n") f.write("Proxies\n-----------------------------\n") output = os.popen("scutil --proxy 2>&1").read().rstrip() f.write(output + "\n\n") f.write("pf rules\n-----------------------------\n") output = os.popen("sudo pfctl -s rules 2>&1").read().rstrip() f.write(output + "\n\n") f.close self.pathsToCollect.append("/etc/hosts") Collector.collect(self)
def collect(self): # Collect unified logs, using arguments passed in settings if os.path.exists("/usr/bin/log"): outputPath = self.collectionPath if self.unifiedLogArguments: logCommand = "log collect {0} --output {1} 2>/dev/null".format( self.unifiedLogArguments, outputPath) else: logCommand = "log collect --output {0} 2>/dev/null".format( outputPath) print "WARNING: collecting unified logs without arguments will result in a very large amount of data!" os.popen(logCommand) # Collect pre-unified log artifacts systemLogPaths = glob.glob("/var/log/system*") if len(systemLogPaths) > 0: self.pathsToCollect = self.pathsToCollect + systemLogPaths self.pathsToCollect.append("/var/log/asl/") if self.collectAuditLogs: self.pathsToCollect.append("/var/audit/") Collector.collect(self)
def main(): f = open('try_3.txt', 'w') g = open('accs.txt', 'w') g.close() task = MarioTask("testbed", initMarioMode=2) task.env.initMarioMode = 2 task.env.levelDifficulty = 1 task.env.BASE_LEVEL = 500000 results = [] names = [] iterations = 20 rounds = 30 learning_samples = 33 eval_samples = 10 # iterations = 5 # rounds = 2 # learning_samples = 3 # eval_samples = 2 if args['noisy']: agent = NoisySupervise(IT, useKMM=False) dire = './training_data_noisy/' else: agent = Supervise(IT, useKMM=False) dire = './training_data/' exp = EpisodicExperiment(task, agent) C = Collector(agent, exp) C.collect(rounds=rounds, iterations=iterations, learning_samples=learning_samples, eval_samples=eval_samples, directory=dire) print "finished"
def collect(self): filename = "browser_extensions.txt" filePath = self.collectionPath + filename f = open(filePath, "w+") f.write("Safari extensions\n-----------------------------\n") output = self.collectSafari() f.write(output + "\n\n") f.write("Chrome extensions\n-----------------------------\n") output = self.collectChrome() f.write(output + "\n\n") f.write("Firefox extensions\n-----------------------------\n") output = self.collectFirefox() f.write(output + "\n\n") f.write("Safari app extensions\n-----------------------------\n") output = self.collectSafariAppExtensions() f.write(output) f.close Collector.collect(self)
def main(): f = open('try_3.txt','w') g = open('accs.txt', 'w') g.close() task = MarioTask("testbed", initMarioMode = 2) task.env.initMarioMode = 2 task.env.levelDifficulty = 1 task.env.BASE_LEVEL = 500000 results = [] names = [] iterations = 20 rounds = 30 learning_samples = 33 eval_samples = 10 # iterations = 5 # rounds = 2 # learning_samples = 3 # eval_samples = 2 if args['noisy']: agent = NoisySupervise(IT, useKMM = False) dire = './training_data_noisy/' else: agent = Supervise(IT, useKMM = False) dire = './training_data/' exp = EpisodicExperiment(task, agent) C = Collector(agent,exp) C.collect(rounds = rounds, iterations = iterations, learning_samples = learning_samples, eval_samples = eval_samples, directory=dire) print "finished"
def create_db(self) -> None: """Create database, collect data and insert them.""" print("creating tables...") Base.metadata.create_all(self.engine) print("tables created") print("uploading data from api...") collector = Collector() data = collector.collect() cleaner = Cleaner() data_cleaned = cleaner.cleaner(data) print("upload successful") print("adding data to tables...") installer = Installer() installer.install(data_cleaned, self.engine) print("database install with success")
def option_critic_run(defaults): collector = Collector(**defaults) env = Game(**defaults) buffer = ReplayBuffer(**defaults) batch = env.batch num_options = len(env.layers.layers) - 3 option_critic = OptionCriticConv(in_features=env.board.shape[1], num_actions=4, num_options=num_options, width=env.board.shape[2], height=env.board.shape[3], temperature=0.005, eps_start=2000000, eps_min=0.2, eps_decay=2000000, eps_test=0.05, device=device) # Create a prime network for more stable Q values option_critic_prime = deepcopy(option_critic) optim = torch.optim.RMSprop(option_critic.parameters(), lr=0.0005) with Save(env, collector, **defaults) as save: states = option_critic.get_state(env.board) greedy_options = [ e.item() for e in list(option_critic.greedy_option(states)) ] current_options = [0 for _ in range(batch)] option_terminations = [True for _ in range(batch)] dones = [False for _ in range(batch)] actions, logps, entropys = [None for _ in range(batch) ], [None for _ in range(batch) ], [None for _ in range(batch)] for frame in loop(env, collector, save): epsilon = option_critic.epsilon #print(epsilon) states = option_critic.get_state(env.board) #print(states.shape) for i, done in enumerate(dones): if done: greedy_options[i] = option_critic.greedy_option( states[i]).item() current_options[i] = 0 option_terminations[i] = True actions[i] = None logps[i] = None entropys[i] = None #print(greedy_options) for i, (option_termination, current_option, state, greedy_option) in enumerate( zip(option_terminations, current_options, states, greedy_options)): if option_termination: current_options[i] = np.random.choice( num_options ) if np.random.rand() < epsilon else greedy_option actions[i], logps[i], entropys[i] = option_critic.get_action( state, current_option) # print(logps[0], entropys[0]) old_obses = env.board next_obses, rewards, dones, _ = env.step(torch.tensor(actions)) collector.collect([rewards], [dones]) buffer.save_option_critic(old_obses, current_options, rewards, next_obses, dones) states = option_critic.get_state(next_obses) loss = 0 for i, (next_obs, reward, done, state, current_option, old_obs, logp, entropy) in enumerate( zip(next_obses, rewards, dones, states, current_options, old_obses, logps, entropys)): option_terminations[i], greedy_options[ i] = option_critic.predict_option_termination( state.unsqueeze(0), current_option) loss += actor_loss_fn(old_obs, current_option, logp, entropy, reward, done, next_obs, option_critic, option_critic_prime) if frame % update_frequency == 0: data_batch = buffer.sample_option_critic() loss += critic_loss_fn(option_critic, option_critic_prime, data_batch) optim.zero_grad() loss.backward() optim.step() if frame % freeze_interval == 0: option_critic_prime = deepcopy(option_critic)
def collect(self, folder_names): collector = Collector() registry = collector.collect(folder_names) for event in registry: self.__register_event__(event)
def test_collector(self): col = Collector() col.collect(r"E:\\huawei-20151212") print("程序计数值为%d" % (col.count))
def collect(self): basicsFilename = "basic_info.txt" basicsFilePath = util.safePathJoin(self.collectionPath, basicsFilename) f = open(basicsFilePath, "w+") user = os.popen("logname").read().rstrip() when = datetime.utcnow().strftime("%-d %b %Y @ %H:%M:%S UTC") whenlocal = datetime.now().strftime("%-d %b %Y @ %H:%M:%S") f.write("Collected by user {0} on {1} (local {2})\n".format( user, when, whenlocal)) uptime = os.popen("uptime").read().rstrip() f.write("Uptime: {0}\n".format(uptime)) hostname = os.popen("hostname").read().rstrip() f.write("Hostname: {0}\n".format(hostname)) spctlStatus = os.popen("spctl --status").read().rstrip() f.write("System policy security: {0}\n".format(spctlStatus)) if spctlStatus != "assessments enabled": f.write(" Gatekeeper is disabled!\n") sipStatus = os.popen("csrutil status").read().rstrip() + "\n" f.write(sipStatus) filevaultStatus = os.popen("fdesetup status").read().rstrip() f.write("FileVault status: {0}\n".format(filevaultStatus)) firewallStatus = os.popen( "defaults read /Library/Preferences/com.apple.alf globalstate" ).read().rstrip() if firewallStatus == "0": f.write("Application firewall is not enabled\n") else: f.write("Application firewall is enabled\n") # Concerning things... if os.path.exists("/private/etc/kcpassword"): f.write("WARNING! Automatic login is enabled by user!\n") result = os.system( "egrep -i '127\.0\.0\.1\s*.*activate.*\.adobe\.com' /Users/thomas/Desktop/hosts &>/dev/null" ) if result == 0: f.write("WARNING! Hosts file shows signs of piracy activity!\n") # System profiler stuff f.write("\n") systemOverview = os.popen( "system_profiler SPSoftwareDataType").read().rstrip() f.write(systemOverview) f.write("\n\n") hardwareOverview = os.popen( "system_profiler SPHardwareDataType").read().rstrip() f.write(hardwareOverview) f.write("\n\n") # Users f.write("User list\n-----------------------------\n") users = os.popen("dscl . list /Users | grep -v '_'").read().rstrip() userlist = users.split("\n") for user in userlist: if user != "daemon" and user != "nobody": userInfo = os.popen("dscacheutil -q user -a name {0}".format( user)).read().rstrip() f.write(userInfo + "\n\n") f.write("Admin users\n-----------------------------\n") users = os.popen( "dscl . -read /Groups/admin GroupMembership").read().rstrip() userlist = users.split()[1:] for user in userlist: f.write(user + "\n") f.write("\n") # Login activity f.write("Users logged in\n-----------------------------\n") users = os.popen("w").read().rstrip() f.write(users + "\n\n") f.write("Last logins\n-----------------------------\n") users = os.popen("last").read().rstrip() f.write(users + "\n\n") f.close Collector.collect(self)
def train_policy(seed): #construct envs def MakeEnv(): return TimeLimit(CartPoleContinousEnv(), max_episode_steps=200) def IsStop(reward): return reward >= 200 train_env = VectorEnv([MakeEnv for _ in range(16)]) test_env = VectorEnv([MakeEnv for _ in range(100)]) #seed np.random.seed(seed) torch.manual_seed(seed) train_env.seed(seed) test_env.seed(seed) #construct policy device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") net = Network((4), (1), 1.0, device).to(device) optimizer = torch.optim.Adam(net.parameters(), lr=1e-3) policy = PPO(net, optimizer) #construct collector train_collector = Collector(train_env, policy) test_collector = Collector(test_env, policy) total_duration = 0 #train policy for _ in range(H_num_epochs): start_time = time.time() #collect experience train_collector.clear_buffer() result = train_collector.collect(n_step=H_steps_per_iter) batch = train_collector.get_experience() #train model train_metric = policy.train(batch, H_repeat) total_duration += time.time() - start_time avg_metric = {} for k, v in train_metric.items(): avg_metric[k] = np.mean(v) tqdm.write(str(result)) tqdm.write(str(avg_metric)) #need to stop? if IsStop(result["rew"]): #test test_result = test_collector.collect(n_episode=H_test_episodes) if IsStop(test_result["rew"]): break train_env.close() test_env.close() #visualize result render_env = VectorEnv([MakeEnv for _ in range(1)]) render_collector = Collector(render_env, policy) render_collector.collect(n_episode=1, render=True) render_env.close() return total_duration
def main(): conf = parse_options() client = Client(conf) collector = Collector(client, conf) collector.collect(conf.start_user) nx.write_dot(collector.graph, conf.output_file)