def main(): print("Trying to login as {}...".format(dvwa_user)) sess = Session(base_url) sess.login('login.php', dvwa_user, dvwa_pass) print("Logged in as {}!".format(dvwa_user)) execute_attack(get_args(), sess)
def topology(self, numnodes, linkprob, verbose=False): """ Build a topology consisting of the given number of ManetNodes connected to a WLAN and probabilty of links and set the session, WLAN, and node list objects. """ # IP subnet prefix = ipaddress.Ipv4Prefix("10.14.0.0/16") self.session = Session(1) # emulated network self.net = self.session.add_object(cls=nodes.WlanNode) for i in xrange(1, numnodes + 1): addr = "%s/%s" % (prefix.addr(i), 32) tmp = self.session.add_object(cls=ManetNode, ipaddr=addr, objid="%d" % i, name="n%d" % i) tmp.newnetif(self.net, [addr]) self.nodes.append(tmp) # connect nodes with probability linkprob for i in xrange(numnodes): for j in xrange(i + 1, numnodes): r = random.random() if r < linkprob: if self.verbose: self.info("linking (%d,%d)" % (i, j)) self.net.link(self.nodes[i].netif(0), self.nodes[j].netif(0)) # force one link to avoid partitions (should check if this is needed) j = i while j == i: j = random.randint(0, numnodes - 1) if self.verbose: self.info("linking (%d,%d)" % (i, j)) self.net.link(self.nodes[i].netif(0), self.nodes[j].netif(0)) self.nodes[i].boot() # run the boot.sh script on all nodes to start Quagga for i in xrange(numnodes): self.nodes[i].cmd(["./%s" % self.nodes[i].bootsh])
def createbridgedsession(self, numnodes, verbose=False): """ Build a topology consisting of the given number of LxcNodes connected to a WLAN. """ # IP subnet prefix = ipaddress.Ipv4Prefix("10.0.0.0/16") self.session = Session(1) # emulated network self.net = self.session.add_object(cls=nodes.WlanNode, name="wlan1") prev = None for i in xrange(1, numnodes + 1): addr = "%s/%s" % (prefix.addr(i), 32) tmp = self.session.add_object(cls=nodes.CoreNode, objid=i, name="n%d" % i) tmp.newnetif(self.net, [addr]) self.nodes.append(tmp) self.session.services.addservicestonode(tmp, "router", "IPForward") self.session.services.bootnodeservices(tmp) self.staticroutes(i, prefix, numnodes) # link each node in a chain, with the previous node if prev: self.net.link(prev.netif(0), tmp.netif(0)) prev = tmp
def session(): # configure default nodes node_map = nodemaps.NODES nodeutils.set_node_map(node_map) # create and return session session_fixture = Session(1, persistent=True) session_fixture.master = True assert os.path.exists(session_fixture.session_dir) # load emane services quagga.load_services() utility.load_services() # set location # session_fixture.master = True session_fixture.location.setrefgeo(47.57917, -122.13232, 2.00000) session_fixture.location.refscale = 150.0 # load emane models session_fixture.emane.loadmodels() # return session fixture yield session_fixture # cleanup print "shutting down session" session_fixture.shutdown() assert not os.path.exists(session_fixture.session_dir)
def convert_dictionary_to_session(dictionary: dict) -> Session: session = Session() session.samples.extend( convert_dictionary_to_sample(s) for s in dictionary['samples']) session.events.extend( convert_dictionary_to_event(e) for e in dictionary['events']) session.time_signature = convert_dictionary_to_time_signature( dictionary['time_signature']) session.tempo_bpm = dictionary['tempo'] return session
def __init__(self): Thread.__init__(self) self.session = Session() self.session.add_listener(self) self.play_state = PlayStates.stopped self.playhead = PlayHead() # dummy eventhandler, doesn't actually handle them. Inject acutual one via set_event_handler() self.event_handler: EventHandler = EventHandler() self.clock = Clock(tick_time_ms=1000) self.keep_thread_active = True self.update_looping_position() self.rewind() self.start()
def main(): """ :return: """ setup_logging() op = OptionParser("Usage: %prog [options] " "(tasks_config.json | tasks_config.py)") op.add_option('-o', '--output', default='results.out', help='File where the simulation results are saved.') op.add_option('--scramble', action='store_true', default=False, help='Randomly scramble the words in the tasks for ' 'a human player.') op.add_option('-w', '--show-world', action='store_true', default=False, help='shows a visualization of the world in the console ' '(mainly for debugging)') op.add_option('-d', '--time-delay', default=0, type=float, help='adds some delay between each timestep for easier' ' visualization.') op.add_option('-l', '--learner', default='learners.human_learner.HumanLearner', help='Defines the type of learner.') op.add_option('-v', '--view', default='BaseView', help='Viewing mode.') op.add_option('-s', '--serializer', default='core.serializer.StandardSerializer', help='Sets the encoding of characters into bits') op.add_option('--learner-cmd', help='The cmd to run to launch RemoteLearner.') op.add_option('--learner-port', default=5556, help='Port on which to accept remote learner.') op.add_option('--max-reward-per-task', default=10, type=int, help='Maximum reward that we can give to a learner for' ' a given task.') opt, args = op.parse_args() if len(args) == 0: op.error("Tasks schedule configuration file required.") tasks_config_file = args[0] # Retrieve task configuration logger = logging.getLogger(__name__) logger.info("Starting new evaluation session") serializer = create_serializer(opt.serializer) # Set hoe enviroment produces and interprets a bit signal learner = create_learner(opt.learner, serializer, opt.learner_cmd, opt.learner_port) # Create learner task_scheduler = create_tasks_from_config(tasks_config_file) # Create tasks, add to scheduler to be served env = Environment(serializer, task_scheduler, opt.scramble, opt.max_reward_per_task) # Construct environment session = Session(env, learner, opt.time_delay) # a learning session view = create_view(opt.view, opt.learner, env, session, serializer, opt.show_world) # setup view try: learner.set_view(view) # Send interface to human learner except AttributeError: # not human. pass pass try: view.initialize() # talk session.run() except BaseException: view.finalize() save_results(session, opt.output) raise else: view.finalize()
def main(): usagestr = "usage: %prog [-h] [options] [args]" parser = optparse.OptionParser(usage=usagestr) parser.set_defaults(numnodes=5) parser.add_option("-n", "--numnodes", dest="numnodes", type=int, help="number of nodes") def usage(msg=None, err=0): sys.stdout.write("\n") if msg: sys.stdout.write(msg + "\n\n") parser.print_help() sys.exit(err) # parse command line options (options, args) = parser.parse_args() if options.numnodes < 1: usage("invalid number of nodes: %s" % options.numnodes) for a in args: sys.stderr.write("ignoring command line argument: '%s'\n" % a) start = datetime.datetime.now() # IP subnet prefix = ipaddress.Ipv4Prefix("10.83.0.0/16") session = Session(1, persistent=True) if 'server' in globals(): server.addsession(session) # emulated Ethernet switch switch = session.add_object(cls=nodes.SwitchNode, name="switch") switch.setposition(x=80, y=50) print "creating %d nodes with addresses from %s" % (options.numnodes, prefix) for i in xrange(1, options.numnodes + 1): tmp = session.add_object(cls=nodes.CoreNode, name="n%d" % i, objid=i) tmp.newnetif(switch, ["%s/%s" % (prefix.addr(i), prefix.prefixlen)]) tmp.cmd([constants.SYSCTL_BIN, "net.ipv4.icmp_echo_ignore_broadcasts=0"]) tmp.setposition(x=150 * i, y=150) n.append(tmp) session.node_count = str(options.numnodes + 1) session.instantiate() print "elapsed time: %s" % (datetime.datetime.now() - start) # start a shell on node 1 n[1].term("bash") raw_input("press enter to exit") session.shutdown()
class TestSession(unittest.TestCase): def setUp(self): self.config_file = "config/config.conf" self.session = Session(self.config_file) def test_session(self): self.assertTrue(self.session.is_alive()) self.assertIsNotNone(self.session.get_config()) self.assertTrue(self.session.is_listening()) def test_session_settings(self): settings = self.session.settings() config = self.session.get_config() self.assertEqual(settings['download_rate_limit'], config['max_download_speed']) self.assertEqual(settings['upload_rate_limit'], config['max_upload_speed']) self.assertEqual(settings['active_downloads'], config['max_active_downloads']) self.assertEqual(settings['active_seeds'], config['max_active_seeds']) self.assertEqual(self.session.data_queue.get_limit(), config['max_torrents']) def tearDown(self): self.session.destruct_session()
def __init__(self): self.midi_exporter = MidiUtil_MidiFileSessionExporter() self.json_importer = JsonFileSessionImporter() self.session = Session() self.session_editor = SessionEditor() self.sequencer = Sequencer() self.sequencer.set_event_handler(SimpleAudio_EventHandler()) self.json_exporter = JsonFileSessionExporter() self.generator = EuclideanRhythmGenerator()
def session(self): if hasattr(self, "_session"): return self._session sessionid = self.get_secure_cookie('sid') if sessionid: sessionid = sessionid.decode("utf-8") self._session = Session(self.application.session_store, sessionid) return self._session
def __init__(self): midi_out = MidiDriver.get_midi_device_id(out=True) midi_in = MidiDriver.get_midi_device_id(out=False) self.auto_start_threshold = [] self.midi_out = midi_out self.midi_in = midi_in midi = MidiDriver(midi_out, midi_in) self._sess = Session(midi) midi.midi_in.set_callback(self._sess.on_midi)
def createemanesession(self, numnodes, verbose=False, cls=None, values=None): """ Build a topology consisting of the given number of LxcNodes connected to an EMANE WLAN. """ prefix = ipaddress.Ipv4Prefix("10.0.0.0/16") self.session = Session(2) self.session.node_count = str(numnodes + 1) self.session.master = True self.session.location.setrefgeo(47.57917, -122.13232, 2.00000) self.session.location.refscale = 150.0 self.session.config["emane_models"] = "RfPipe, Ieee80211abg, Bypass" self.session.emane.loadmodels() self.net = self.session.add_object(cls=EmaneNode, objid=numnodes + 1, name="wlan1") self.net.verbose = verbose # self.session.emane.addobj(self.net) for i in xrange(1, numnodes + 1): addr = "%s/%s" % (prefix.addr(i), 32) tmp = self.session.add_object(cls=nodes.CoreNode, objid=i, name="n%d" % i) # tmp.setposition(i * 20, 50, None) tmp.setposition(50, 50, None) tmp.newnetif(self.net, [addr]) self.nodes.append(tmp) self.session.services.addservicestonode(tmp, "router", "IPForward") if values is None: values = cls.getdefaultvalues() self.session.emane.setconfig(self.net.objid, cls.name, values) self.session.instantiate() self.info("waiting %s sec (TAP bring-up)" % 2) time.sleep(2) for i in xrange(1, numnodes + 1): tmp = self.nodes[i - 1] self.session.services.bootnodeservices(tmp) self.staticroutes(i, prefix, numnodes)
def __session_checked_in(self, checkin_tuple): guid, remote_addr = checkin_tuple for session in self.sessions: if session.guid == guid: session.checked_in() try: return session.queue.get(block=False) except Empty: return print_info(f"Re-attaching orphaned session from {remote_addr} ...") self.__add_session(Session(guid, remote_addr, {}))
def kex(self, kex_tuple): guid, remote_addr, pubkey_xml = kex_tuple try: session = list(filter(lambda x: x == guid, self.sessions))[0] logging.debug(f"creating new pub/priv keys for {guid}") session.set_peer_public_key(pubkey_xml) except IndexError: logging.debug(f"new kex from {remote_addr} ({guid})") session = Session(guid, remote_addr, pubkey_xml) self.sessions.add(session) return session.public_key
def new_session(self): """Create a new session Produces a new session and adds it to the core's list of session objects. The active session is then set to the newly created session. """ new_sess = Session() self.sessions.append(new_sess) self.active_session_index = len(self.sessions) - 1 self.active_session = self.sessions[self.active_session_index] print("[+] New session created")
def logout(request, session_id): unauth_session = get_unauth_session(request) try: # Update the unauth session with the hacker bucks and flags session = Session.get_session(session_id) unauth_session.from_other_session(session) except KeyError: pass AuthenticatedSession.logout(session_id) return redirect("crapdb:index")
def sync_session(request, session_id): ret = {} unauth_session = get_unauth_session(request) try: # Update the unauth session with the hacker bucks and flags session = Session.get_session(session_id) unauth_session.from_other_session(session) except KeyError: pass ret = {"hacker_bucks": unauth_session.hacker_bucks} return HttpResponse(json.dumps(ret))
def process_world(conn, opt, tasks_config_file, world_id): try: serializer = StandardSerializer() task_scheduler = create_tasks_from_config(tasks_config_file) env = Environment(serializer, task_scheduler, opt.scramble, opt.max_reward_per_task, not opt.bit_mode) learner = create_learner(opt.learner, serializer, opt.learner_cmd, opt.learner_port, not opt.bit_mode) session = Session(env, learner, opt.time_delay) args = conn.recv() while not (args is None): episode_id, step_count, seed, weight = args # INTERACTION BETWEEN ENVIRONMENT AND AGENT learner.net.set_genotype_weight(weight, seed) del weight episode_reward = session.iterate_n(step_count) # save_results(session, opt.output) conn.send((episode_reward, seed)) args = conn.recv() except BaseException as e: print(e) conn.send(None)
def __init__(self, serial, port, app_name): self._serial = serial # 会话 # webdriver.Remote self._session = Session(serial, port, Config.get_session(app_name)).get_session() # 处理器 self._processor = Config.get_processor(app_name)(serial, self._session) # 任务生产者 self._producer = Config.get_producer(app_name)() # 工具集 self._appium_tools = AppiumTools(self._serial, self._session)
def kex(self, kex_tuple): guid, remote_addr, pubkey_xml = kex_tuple if self.sessions and not len(self.sessions): return try: session = self.get(guid) logging.debug(f"creating new pub/priv keys for {guid}") session.set_peer_public_key(pubkey_xml) except IndexError: logging.debug(f"new kex from {remote_addr} ({guid})") session = Session(guid, remote_addr, pubkey_xml) self.sessions.add(session) return session.public_key
def download(session, url, path): res = session.get(url) if (len(res) == 0): return False # no submissions job_url = routes.ROOT + cooljson.parse_json(res).get( "redirect_url", None) + "?format=json" counter = 0 while counter < Project.TIMEOUT_TRIES: res = session.get(job_url) data = cooljson.parse_json(res) status = data.get("status", None) download_url = None if (status == "completed"): download_url = data.get("redirect_url") break time.sleep(Project.CHECK_INTERVAL) counter += 1 return Session.download(routes.ROOT + download_url, path)
def createbridgedsession(self, numnodes, verbose=False): """ Build a topology consisting of the given number of LxcNodes connected to a WLAN. """ # IP subnet prefix = ipaddress.Ipv4Prefix("10.0.0.0/16") self.session = Session(1) # emulated network self.net = self.session.add_object(cls=nodes.WlanNode, name="wlan1") prev = None for i in xrange(1, numnodes + 1): addr = "%s/%s" % (prefix.addr(i), 32) tmp = self.session.add_object(cls=nodes.CoreNode, objid=i, name="n%d" % i) tmp.newnetif(self.net, [addr]) self.nodes.append(tmp) self.session.services.add_services(tmp, "router", "IPForward") self.session.services.boot_services(tmp) self.staticroutes(i, prefix, numnodes) # link each node in a chain, with the previous node if prev: self.net.link(prev.netif(0), tmp.netif(0)) prev = tmp
def test(numnodes, testsec): # node list n = [] # IP subnet prefix = ipaddress.Ipv4Prefix("10.83.0.0/16") session = Session(1) # emulated network net = session.add_object(cls=nodes.SwitchNode) for i in xrange(1, numnodes + 1): tmp = session.add_object(cls=nodes.LxcNode, name="n%d" % i) tmp.newnetif(net, ["%s/%s" % (prefix.addr(i), prefix.prefixlen)]) n.append(tmp) n[0].cmd(["iperf", "-s", "-D"]) n[-1].icmd(["iperf", "-t", str(int(testsec)), "-c", str(prefix.addr(1))]) n[0].cmd(["killall", "-9", "iperf"]) raw_input("press enter to exit") session.shutdown()
def createemanesession(self, numnodes, verbose=False, cls=None, values=None): """ Build a topology consisting of the given number of LxcNodes connected to an EMANE WLAN. """ prefix = ipaddress.Ipv4Prefix("10.0.0.0/16") self.session = Session(2) self.session.node_count = str(numnodes + 1) self.session.master = True self.session.location.setrefgeo(47.57917, -122.13232, 2.00000) self.session.location.refscale = 150.0 self.session.emane.loadmodels() self.net = self.session.add_object(cls=EmaneNode, objid=numnodes + 1, name="wlan1") self.net.verbose = verbose # self.session.emane.addobj(self.net) for i in xrange(1, numnodes + 1): addr = "%s/%s" % (prefix.addr(i), 32) tmp = self.session.add_object(cls=nodes.CoreNode, objid=i, name="n%d" % i) # tmp.setposition(i * 20, 50, None) tmp.setposition(50, 50, None) tmp.newnetif(self.net, [addr]) self.nodes.append(tmp) self.session.services.add_services(tmp, "router", "IPForward") if values is None: values = cls.getdefaultvalues() self.session.emane.setconfig(self.net.objid, cls.name, values) self.session.instantiate() self.info("waiting %s sec (TAP bring-up)" % 2) time.sleep(2) for i in xrange(1, numnodes + 1): tmp = self.nodes[i - 1] self.session.services.boot_services(tmp) self.staticroutes(i, prefix, numnodes)
def create_session(self, session_id=None): """ Convenience method for creating sessions with the servers config. :param int session_id: session id for new session :return: create session :rtype: core.session.Session """ # create random id when necessary, seems to be 1 case wanted, based on legacy code # creating a value so high, typical client side generation schemes hopefully wont collide if not session_id: session_id = next(session_id for session_id in xrange(60000, 65000) if session_id not in self.sessions) # create and add session to local manager session = Session(session_id, config=self.config) self.add_session(session) # add shutdown handler to remove session from manager session.shutdown_handlers.append(self.session_shutdown) return session
def test(options): prefix = ipaddress.Ipv4Prefix("10.83.0.0/16") session = Session(1, persistent=True) if options.enablesdt: # GUI default session.location.setrefgeo(47.57917, -122.13232, 50.0) session.location.refscale = 100.0 session.options.enablesdt = True session.options.sdturl = options.sdturl wlanid = options.numnodes + 1 net = session.add_object(cls=WlanNode, name="wlan%d" % wlanid, objid=wlanid) values = list(BasicRangeModel.getdefaultvalues()) # values[0] = 5000000 # 5000km range net.setmodel(BasicRangeModel, values) for i in xrange(1, options.numnodes + 1): node = session.add_object(cls=LxcNode, name="n%d" % i, objid=i) address = "%s/%s" % (prefix.addr(i), prefix.prefixlen) print "setting node address: %s - %s" % (node.objid, address) node.newnetif(net, [address]) # set increasing Z coordinates node.setposition(10, 10, 100) n.append(node) # example setting node n2 to a high altitude # n[1].setposition(10, 10, 2000000) # 2000km # session.sdt.updatenode(n[1].objid, 0, 10, 10, 2000000) # launches terminal for the first node # n[0].term("bash") n[0].icmd(["ping", "-c", "5", "127.0.0.1"]) # wait for rate seconds to allow ebtables commands to commit time.sleep(EbtablesQueue.rate) raw_input("press enter to exit") session.shutdown()
js_function="brutalForce()", sort_order=1 ) def __init__(self): super().__init__() random.seed() # uses current system time self.pin = random.randint(666, 9999) # The user's random PIN number self.pin_hash = hashlib.sha256(str(self.pin).encode('utf-8')).hexdigest() def to_json(self): obj = super().to_json() obj.update({ "pin_hash": self.pin_hash }) return obj def check(self, answer): try: answer = int(answer) if answer < 1 or answer > 9999: return False except ValueError: return False if answer == self.pin: self.solved = True return True return False Session.register_challenge(BrutalForce)
def setUp(self): self.config_file = "config/config.conf" self.session = Session(self.config_file)
self.cipher = self.sxor(self.cipher_key, self.message) def generate_key(self): key_len = 6 for _ in range(key_len): self.key += self.alnum[random.randint(0, (len(self.alnum) - 1))] self.cipher_key = str(self.key) * (int(len(self.message) / len(self.key)) + 1) def sxor(self, s1, s2): # convert strings to a list of character pair tuples # go through each tuple, converting them to ASCII code (ord) # perform exclusive or on the ASCII code # then convert the result back to ASCII (chr) # merge the resulting array of characters as a string return bytes([(ord(a) ^ ord(b)) for a, b in zip(s1, s2)]) def to_json(self): obj = super().to_json() obj.update({ "cipher_text": str(self.cipher.hex()) }) return obj def check(self, answer): if answer.strip() == self.key or answer.strip() == self.cipher_key: self.solved = True return True return False Session.register_challenge(Xor)
super().__init__() random.seed() self.password = "" self.score = 0 for _ in range(self.password_len): self.password += self.chars[random.randint(0, len(self.chars) - 1)] def to_json(self): obj = super().to_json() obj.update({ "score": self.score }) return obj def get_fitness(self, answer): score = 0 for i, c in enumerate(answer): if self.password[i] == c: score += 1 self.score = (score / len(self.password)) * 100 if self.score == 100: # Only solved when the score is 100 self.solved = True def check(self, answer): answer = answer.strip() self.get_fitness(answer) return True Session.register_challenge(Genetic)
def main(): usagestr = "usage: %prog [-h] [options] [args]" parser = optparse.OptionParser(usage=usagestr) parser.set_defaults(numnodes=5) parser.add_option("-n", "--numnodes", dest="numnodes", type=int, help="number of nodes") def usage(msg=None, err=0): sys.stdout.write("\n") if msg: sys.stdout.write(msg + "\n\n") parser.print_help() sys.exit(err) # parse command line options (options, args) = parser.parse_args() if options.numnodes < 1: usage("invalid number of nodes: %s" % options.numnodes) for a in args: sys.stderr.write("ignoring command line argument: '%s'\n" % a) start = datetime.datetime.now() # IP subnet prefix = ipaddress.Ipv4Prefix("10.83.0.0/16") # session with some EMANE initialization cfg = {'verbose': 'false'} session = Session(1, config=cfg, persistent=True) session.master = True session.location.setrefgeo(47.57917, -122.13232, 2.00000) session.location.refscale = 150.0 session.config['emane_models'] = "RfPipe, Ieee80211abg, Bypass" session.emane.loadmodels() if 'server' in globals(): server.addsession(session) # EMANE WLAN print "creating EMANE WLAN wlan1" wlan = session.add_object(cls=EmaneNode, name="wlan1") wlan.setposition(x=80, y=50) names = EmaneIeee80211abgModel.getnames() values = list(EmaneIeee80211abgModel.getdefaultvalues()) # TODO: change any of the EMANE 802.11 parameter values here for i in range(0, len(names)): print "EMANE 80211 \"%s\" = \"%s\"" % (names[i], values[i]) try: values[names.index('pathlossmode')] = '2ray' except ValueError: values[names.index('propagationmodel')] = '2ray' session.emane.setconfig(wlan.objid, EmaneIeee80211abgModel.name, values) services_str = "zebra|OSPFv3MDR|IPForward" print "creating %d nodes with addresses from %s" % \ (options.numnodes, prefix) for i in xrange(1, options.numnodes + 1): tmp = session.add_object(cls=nodes.CoreNode, name="n%d" % i, objid=i) tmp.newnetif(wlan, ["%s/%s" % (prefix.addr(i), prefix.prefixlen)]) tmp.cmd( [constants.SYSCTL_BIN, "net.ipv4.icmp_echo_ignore_broadcasts=0"]) tmp.setposition(x=150 * i, y=150) session.services.addservicestonode(tmp, "", services_str) n.append(tmp) # this starts EMANE, etc. session.node_count = str(options.numnodes + 1) session.instantiate() # start a shell on node 1 n[1].term("bash") print "elapsed time: %s" % (datetime.datetime.now() - start)
def shutdown(self): # TODO: the following line tends to segfault ns-3 (and therefore core-daemon) ns.core.Simulator.Destroy() Session.shutdown(self)
from core.challenge import Challenge, ChallengeMetadata from core.session import Session, AuthenticatedSession from flags import FlagGenerator FLAGS = FlagGenerator.generate_flags() class PaidContent(Challenge): meta = ChallengeMetadata( challenge_id="paid_content", name="Paid Content", description="Pay for things you want!", price=25, value=FLAGS["paid_content_challenge"][1], flag=FLAGS["paid_content_challenge"][0], js_function="paidContent()", sort_order=2 ) def check(self, answer): if isinstance(answer, AuthenticatedSession): if answer.paid: self.solved = True return True return False Session.register_challenge(PaidContent)
from core.challenge import Challenge, ChallengeMetadata from core.session import Session from flags import FlagGenerator FLAGS = FlagGenerator.generate_flags() class SentenceBot(Challenge): meta = ChallengeMetadata( challenge_id="sentence_bot", name="Sentence Bot", description="RE The Flag", price=0, value=FLAGS["sentence_bot_challenge"][1], flag="", sort_order=0, js_function="sentenceBot()" ) def __init__(self): super().__init__() self.solved = True self.purchased = True def check(self, answer): self.solved = True return True Session.register_challenge(SentenceBot)
def main(): setup_logging() op = OptionParser("Usage: %prog [options] " "(tasks_config.json | tasks_config.py)") op.add_option('-o', '--output', default='results.out', help='File where the simulation results are saved.') op.add_option('--scramble', action='store_true', default=False, help='Randomly scramble the words in the tasks for ' 'a human player.') op.add_option('-w', '--show-world', action='store_true', default=False, help='shows a visualization of the world in the console ' '(mainly for debugging)') op.add_option('-d', '--time-delay', default=0, type=float, help='adds some delay between each timestep for easier' ' visualization.') op.add_option('-l', '--learner', default='learners.human_learner.HumanLearner', help='Defines the type of learner.') op.add_option('-v', '--view', default='BaseView', help='Viewing mode.') op.add_option('--learner-cmd', help='The cmd to run to launch RemoteLearner.') op.add_option('--learner-port', default=5556, type=int, help='Port on which to accept remote learner.') op.add_option('--learner-address', help='Network address on which the remote learner listens.') op.add_option('--max-reward-per-task', default=2147483647, type=int, help='Maximum reward that we can give to a learner for' ' a given task.') op.add_option('--curses', action='store_true', default=False, help='Uses standard output instead of curses library.') op.add_option('--bit-mode', action='store_true', default=False, help='Environment receives input in bytes.') opt, args = op.parse_args() if len(args) == 0: op.error("Tasks schedule configuration file required.") # retrieve the task configuration file tasks_config_file = args[0] logger = logging.getLogger(__name__) logger.info("Starting new evaluation session") # we choose how the environment will produce and interpret # the bit signal serializer = StandardSerializer() # create a learner (the human learner takes the serializer) learner = create_learner(opt.learner, serializer, opt.learner_cmd, opt.learner_port, opt.learner_address, not opt.bit_mode) # create our tasks and put them into a scheduler to serve them task_scheduler = create_tasks_from_config(tasks_config_file) # construct an environment env = Environment(serializer, task_scheduler, opt.scramble, opt.max_reward_per_task, not opt.bit_mode) # a learning session session = Session(env, learner, opt.time_delay) # setup view view = create_view(opt.view, opt.learner, env, session, serializer, opt.show_world, opt.curses, not opt.bit_mode) try: # send the interface to the human learner learner.set_view(view) except AttributeError: # this was not a human learner, nothing to do pass try: view.initialize() # ok guys, talk session.run() except BaseException: view.finalize() save_results(session, opt.output) raise else: view.finalize()
def main(): usagestr = "usage: %prog [-n] number of nodes [-d] daemon address" parser = optparse.OptionParser(usage=usagestr) parser.set_defaults(numnodes=5, daemon="127.0.0.1:" + str(CORE_API_PORT)) parser.add_option("-n", "--numnodes", dest="numnodes", type=int, help="number of nodes") parser.add_option("-d", "--daemon-server", dest="daemon", type=str, help="daemon server IP address") def usage(msg=None, err=0): sys.stdout.write("\n") if msg: sys.stdout.write(msg + "\n\n") parser.print_help() sys.exit(err) # parse command line options (options, args) = parser.parse_args() if options.numnodes < 1: usage("invalid number of nodes: %s" % options.numnodes) if not options.daemon: usage("daemon server IP address (-d) is a required argument") for a in args: sys.stderr.write("ignoring command line argument: %s\n" % a) start = datetime.datetime.now() prefix = ipaddress.Ipv4Prefix("10.83.0.0/16") session = Session(1) if "server" in globals(): server.addsession(session) # distributed setup - connect to daemon server daemonport = options.daemon.split(":") daemonip = daemonport[0] # Localhost is already set in the session but we change it to be the remote daemon # This stops the remote daemon trying to build a tunnel back which would fail daemon = "localhost" if len(daemonport) > 1: port = int(daemonport[1]) else: port = CORE_API_PORT print "connecting to daemon at %s:%d" % (daemon, port) session.broker.addserver(daemon, daemonip, port) # Set the local session id to match the port. # Not necessary but seems neater. session.broker.setupserver(daemon) # We do not want the recvloop running as we will deal ourselves session.broker.dorecvloop = False # Change to configuration state on both machines session.set_state(EventTypes.CONFIGURATION_STATE) tlvdata = coreapi.CoreEventTlv.pack(EventTlvs.TYPE.value, EventTypes.CONFIGURATION_STATE.value) session.broker.handlerawmsg(coreapi.CoreEventMessage.pack(0, tlvdata)) flags = MessageFlags.ADD.value switch = nodes.SwitchNode(session=session, name="switch", start=False) switch.setposition(x=80, y=50) switch.server = daemon switch_data = switch.data(flags) switch_message = dataconversion.convert_node(switch_data) session.broker.handlerawmsg(switch_message) number_of_nodes = options.numnodes print "creating %d remote nodes with addresses from %s" % (options.numnodes, prefix) # create remote nodes via API for i in xrange(1, number_of_nodes + 1): node = nodes.CoreNode(session=session, objid=i, name="n%d" % i, start=False) node.setposition(x=150 * i, y=150) node.server = daemon node_data = node.data(flags) node_message = dataconversion.convert_node(node_data) session.broker.handlerawmsg(node_message) n.append(node) # create remote links via API for i in xrange(1, number_of_nodes + 1): tlvdata = coreapi.CoreLinkTlv.pack(LinkTlvs.N1_NUMBER.value, switch.objid) tlvdata += coreapi.CoreLinkTlv.pack(LinkTlvs.N2_NUMBER.value, i) tlvdata += coreapi.CoreLinkTlv.pack(LinkTlvs.TYPE.value, LinkTypes.WIRED.value) tlvdata += coreapi.CoreLinkTlv.pack(LinkTlvs.INTERFACE2_NUMBER.value, 0) tlvdata += coreapi.CoreLinkTlv.pack(LinkTlvs.INTERFACE2_IP4.value, prefix.addr(i)) tlvdata += coreapi.CoreLinkTlv.pack(LinkTlvs.INTERFACE2_IP4_MASK.value, prefix.prefixlen) msg = coreapi.CoreLinkMessage.pack(flags, tlvdata) session.broker.handlerawmsg(msg) # We change the daemon to Instantiation state # We do not change the local session as it would try and build a tunnel and fail tlvdata = coreapi.CoreEventTlv.pack(EventTlvs.TYPE.value, EventTypes.INSTANTIATION_STATE.value) msg = coreapi.CoreEventMessage.pack(0, tlvdata) session.broker.handlerawmsg(msg) # Get the ip or last node and ping it from the first print "Pinging from the first to the last node" pingip = cmd(n[-1], "ip -4 -o addr show dev eth0").split()[3].split("/")[0] print cmd(n[1], "ping -c 5 " + pingip) print "elapsed time: %s" % (datetime.datetime.now() - start) print "To stop this session, use the core-cleanup script on the remote daemon server." raw_input("press enter to exit")
def main(): usagestr = "usage: %prog [-h] [options] [args]" parser = optparse.OptionParser(usage=usagestr) parser.set_defaults(numnodes=5, slave=None) parser.add_option("-n", "--numnodes", dest="numnodes", type=int, help="number of nodes") parser.add_option("-s", "--slave-server", dest="slave", type=str, help="slave server IP address") def usage(msg=None, err=0): sys.stdout.write("\n") if msg: sys.stdout.write(msg + "\n\n") parser.print_help() sys.exit(err) # parse command line options (options, args) = parser.parse_args() if options.numnodes < 1: usage("invalid number of nodes: %s" % options.numnodes) if not options.slave: usage("slave server IP address (-s) is a required argument") for a in args: sys.stderr.write("ignoring command line argument: '%s'\n" % a) start = datetime.datetime.now() prefix = ipaddress.Ipv4Prefix("10.83.0.0/16") session = Session(1) if 'server' in globals(): server.addsession(session) # distributed setup - connect to slave server slaveport = options.slave.split(':') slave = slaveport[0] if len(slaveport) > 1: port = int(slaveport[1]) else: port = CORE_API_PORT print "connecting to slave at %s:%d" % (slave, port) session.broker.addserver(slave, slave, port) session.broker.setupserver(slave) session.set_state(EventTypes.CONFIGURATION_STATE) tlvdata = coreapi.CoreEventTlv.pack(EventTlvs.TYPE.value, EventTypes.CONFIGURATION_STATE.value) session.broker.handlerawmsg(coreapi.CoreEventMessage.pack(0, tlvdata)) switch = session.add_object(cls=nodes.SwitchNode, name="switch") switch.setposition(x=80, y=50) num_local = options.numnodes / 2 num_remote = options.numnodes / 2 + options.numnodes % 2 print "creating %d (%d local / %d remote) nodes with addresses from %s" % \ (options.numnodes, num_local, num_remote, prefix) for i in xrange(1, num_local + 1): node = session.add_object(cls=nodes.CoreNode, name="n%d" % i, objid=i) node.newnetif(switch, ["%s/%s" % (prefix.addr(i), prefix.prefixlen)]) node.cmd([constants.SYSCTL_BIN, "net.ipv4.icmp_echo_ignore_broadcasts=0"]) node.setposition(x=150 * i, y=150) n.append(node) flags = MessageFlags.ADD.value session.broker.handlerawmsg(switch.tonodemsg(flags=flags)) # create remote nodes via API for i in xrange(num_local + 1, options.numnodes + 1): node = nodes.CoreNode(session=session, objid=i, name="n%d" % i, start=False) node.setposition(x=150 * i, y=150) node.server = slave n.append(node) node_data = node.data(flags) node_message = dataconversion.convert_node(node_data) session.broker.handlerawmsg(node_message) # create remote links via API for i in xrange(num_local + 1, options.numnodes + 1): tlvdata = coreapi.CoreLinkTlv.pack(LinkTlvs.N1_NUMBER.value, switch.objid) tlvdata += coreapi.CoreLinkTlv.pack(LinkTlvs.N2_NUMBER.value, i) tlvdata += coreapi.CoreLinkTlv.pack(LinkTlvs.TYPE.value, LinkTypes.WIRED.value) tlvdata += coreapi.CoreLinkTlv.pack(LinkTlvs.INTERFACE2_NUMBER.value, 0) tlvdata += coreapi.CoreLinkTlv.pack(LinkTlvs.INTERFACE2_IP4.value, prefix.addr(i)) tlvdata += coreapi.CoreLinkTlv.pack(LinkTlvs.INTERFACE2_IP4_MASK.value, prefix.prefixlen) msg = coreapi.CoreLinkMessage.pack(flags, tlvdata) session.broker.handlerawmsg(msg) session.instantiate() tlvdata = coreapi.CoreEventTlv.pack(EventTlvs.TYPE.value, EventTypes.INSTANTIATION_STATE.value) msg = coreapi.CoreEventMessage.pack(0, tlvdata) session.broker.handlerawmsg(msg) # start a shell on node 1 n[1].client.term("bash") print "elapsed time: %s" % (datetime.datetime.now() - start) print "To stop this session, use the 'core-cleanup' script on this server" print "and on the remote slave server."
from core.challenge import Challenge, ChallengeMetadata from core.session import Session from flags import FlagGenerator FLAGS = FlagGenerator.generate_flags() class SentenceBot(Challenge): meta = ChallengeMetadata(challenge_id="sentence_bot", name="Sentence Bot", description="RE The Flag", price=0, value=FLAGS["sentence_bot_challenge"][1], flag="", sort_order=0, js_function="sentenceBot()") def __init__(self): super().__init__() self.solved = True self.purchased = True def check(self, answer): self.solved = True return True Session.register_challenge(SentenceBot)
def __init__(self, session_id, persistent=False, duration=600): self.duration = duration self.nodes = ns.network.NodeContainer() self.mobhelper = ns.mobility.MobilityHelper() Session.__init__(self, session_id, persistent=persistent)
class SuperAdmin(Challenge): meta = ChallengeMetadata( challenge_id="super_admin", name="Super Admin", description="Are you admin tho?", price=0, value=FLAGS["super_admin_challenge"][1], flag=FLAGS["super_admin_challenge"][0], js_function="superAdmin()", sort_order=0 ) def __init__(self): super().__init__() self.solved = True self.purchased = True def to_json(self): obj = super().to_json() obj.update({ "flag": self.meta.flag }) return obj def check(self, answer): self.solved = True return True Session.register_challenge(SuperAdmin)
class ManetExperiment(object): """ A class for building an MDR network and checking and logging its state. """ def __init__(self, options, start): """ Initialize with options and start time. """ self.session = None # node list self.nodes = [] # WLAN network self.net = None self.verbose = options.verbose # dict from OptionParser self.options = options self.start = start self.logbegin() def info(self, msg): ''' Utility method for writing output to stdout. ''' print msg sys.stdout.flush() self.log(msg) def warn(self, msg): ''' Utility method for writing output to stderr. ''' print >> sys.stderr, msg sys.stderr.flush() self.log(msg) def logbegin(self): """ Start logging. """ self.logfp = None if not self.options.logfile: return self.logfp = open(self.options.logfile, "w") self.log("ospfmanetmdrtest begin: %s\n" % self.start.ctime()) def logend(self): """ End logging. """ if not self.logfp: return end = datetime.datetime.now() self.log("ospfmanetmdrtest end: %s (%s)\n" % \ (end.ctime(), end - self.start)) self.logfp.flush() self.logfp.close() self.logfp = None def log(self, msg): """ Write to the log file, if any. """ if not self.logfp: return print >> self.logfp, msg def logdata(self, nbrs, mdrs, lsdbs, krs, zrs): """ Dump experiment parameters and data to the log file. """ self.log("ospfmantetmdrtest data:") self.log("----- parameters -----") self.log("%s" % self.options) self.log("----- neighbors -----") for rtrid in sorted(nbrs.keys()): self.log("%s: %s" % (rtrid, nbrs[rtrid])) self.log("----- mdr levels -----") self.log(mdrs) self.log("----- link state databases -----") for rtrid in sorted(lsdbs.keys()): self.log("%s lsdb:" % rtrid) for line in lsdbs[rtrid].split("\n"): self.log(line) self.log("----- kernel routes -----") for rtrid in sorted(krs.keys()): msg = rtrid + ": " for rt in krs[rtrid]: msg += "%s" % rt self.log(msg) self.log("----- zebra routes -----") for rtrid in sorted(zrs.keys()): msg = rtrid + ": " for rt in zrs[rtrid]: msg += "%s" % rt self.log(msg) def topology(self, numnodes, linkprob, verbose=False): """ Build a topology consisting of the given number of ManetNodes connected to a WLAN and probabilty of links and set the session, WLAN, and node list objects. """ # IP subnet prefix = ipaddress.Ipv4Prefix("10.14.0.0/16") self.session = Session(1) # emulated network self.net = self.session.add_object(cls=nodes.WlanNode) for i in xrange(1, numnodes + 1): addr = "%s/%s" % (prefix.addr(i), 32) tmp = self.session.add_object(cls=ManetNode, ipaddr=addr, objid="%d" % i, name="n%d" % i) tmp.newnetif(self.net, [addr]) self.nodes.append(tmp) # connect nodes with probability linkprob for i in xrange(numnodes): for j in xrange(i + 1, numnodes): r = random.random() if r < linkprob: if self.verbose: self.info("linking (%d,%d)" % (i, j)) self.net.link(self.nodes[i].netif(0), self.nodes[j].netif(0)) # force one link to avoid partitions (should check if this is needed) j = i while j == i: j = random.randint(0, numnodes - 1) if self.verbose: self.info("linking (%d,%d)" % (i, j)) self.net.link(self.nodes[i].netif(0), self.nodes[j].netif(0)) self.nodes[i].boot() # run the boot.sh script on all nodes to start Quagga for i in xrange(numnodes): self.nodes[i].cmd(["./%s" % self.nodes[i].bootsh]) def compareroutes(self, node, kr, zr): """ Compare two lists of Route objects. """ kr.sort(key=Route.key) zr.sort(key=Route.key) if kr != zr: self.warn("kernel and zebra routes differ") if self.verbose: msg = "kernel: " for r in kr: msg += "%s " % r msg += "\nzebra: " for r in zr: msg += "%s " % r self.warn(msg) else: self.info(" kernel and zebra routes match") def comparemdrlevels(self, nbrs, mdrs): """ Check that all routers form a connected dominating set, i.e. all routers are either MDR, BMDR, or adjacent to one. """ msg = "All routers form a CDS" for n in self.nodes: if mdrs[n.routerid] != "OTHER": continue connected = False for nbr in nbrs[n.routerid]: if mdrs[nbr] == "MDR" or mdrs[nbr] == "BMDR": connected = True break if not connected: msg = "All routers do not form a CDS" self.warn("XXX %s: not in CDS; neighbors: %s" % \ (n.routerid, nbrs[n.routerid])) if self.verbose: self.info(msg) def comparelsdbs(self, lsdbs): """ Check LSDBs for consistency. """ msg = "LSDBs of all routers are consistent" prev = self.nodes[0] for n in self.nodes: db = lsdbs[n.routerid] if lsdbs[prev.routerid] != db: msg = "LSDBs of all routers are not consistent" self.warn("XXX LSDBs inconsistent for %s and %s" % \ (n.routerid, prev.routerid)) i = 0 for entry in lsdbs[n.routerid].split("\n"): preventries = lsdbs[prev.routerid].split("\n") try: preventry = preventries[i] except IndexError: preventry = None if entry != preventry: self.warn("%s: %s" % (n.routerid, entry)) self.warn("%s: %s" % (prev.routerid, preventry)) i += 1 prev = n if self.verbose: self.info(msg) def checknodes(self): """ Check the neighbor state and routing tables of all nodes. """ nbrs = {} mdrs = {} lsdbs = {} krs = {} zrs = {} v = self.verbose for n in self.nodes: self.info("checking %s" % n.name) nbrs[n.routerid] = Ospf6NeighState(n, verbose=v).run() krs[n.routerid] = KernelRoutes(n, verbose=v).run() zrs[n.routerid] = ZebraRoutes(n, verbose=v).run() self.compareroutes(n, krs[n.routerid], zrs[n.routerid]) mdrs[n.routerid] = Ospf6MdrLevel(n, verbose=v).run() lsdbs[n.routerid] = Ospf6Database(n, verbose=v).run() self.comparemdrlevels(nbrs, mdrs) self.comparelsdbs(lsdbs) self.logdata(nbrs, mdrs, lsdbs, krs, zrs)
class Experiment(object): """ Experiment object to organize tests. """ def __init__(self, opt, start): """ Initialize with opt and start time. """ self.session = None # node list self.nodes = [] # WLAN network self.net = None self.verbose = opt.verbose # dict from OptionParser self.opt = opt self.start = start self.numping = opt.numping self.numiperf = opt.numiperf self.nummgen = opt.nummgen self.logbegin() def info(self, msg): """ Utility method for writing output to stdout. """ print msg sys.stdout.flush() self.log(msg) def warn(self, msg): """ Utility method for writing output to stderr. """ print >> sys.stderr, msg sys.stderr.flush() self.log(msg) def logbegin(self): """ Start logging. """ self.logfp = None if not self.opt.logfile: return self.logfp = open(self.opt.logfile, "w") self.log("%s begin: %s\n" % (sys.argv[0], self.start.ctime())) self.log("%s args: %s\n" % (sys.argv[0], sys.argv[1:])) (sysname, rel, ver, machine, nodename) = os.uname() self.log("%s %s %s %s on %s" % (sysname, rel, ver, machine, nodename)) def logend(self): """ End logging. """ if not self.logfp: return end = datetime.datetime.now() self.log("%s end: %s (%s)\n" % \ (sys.argv[0], end.ctime(), end - self.start)) self.logfp.flush() self.logfp.close() self.logfp = None def log(self, msg): """ Write to the log file, if any. """ if not self.logfp: return print >> self.logfp, msg def reset(self): """ Prepare for another experiment run. """ if self.session: self.session.shutdown() del self.session self.session = None self.nodes = [] self.net = None def createbridgedsession(self, numnodes, verbose=False): """ Build a topology consisting of the given number of LxcNodes connected to a WLAN. """ # IP subnet prefix = ipaddress.Ipv4Prefix("10.0.0.0/16") self.session = Session(1) # emulated network self.net = self.session.add_object(cls=nodes.WlanNode, name="wlan1") prev = None for i in xrange(1, numnodes + 1): addr = "%s/%s" % (prefix.addr(i), 32) tmp = self.session.add_object(cls=nodes.CoreNode, objid=i, name="n%d" % i) tmp.newnetif(self.net, [addr]) self.nodes.append(tmp) self.session.services.add_services(tmp, "router", "IPForward") self.session.services.boot_services(tmp) self.staticroutes(i, prefix, numnodes) # link each node in a chain, with the previous node if prev: self.net.link(prev.netif(0), tmp.netif(0)) prev = tmp def createemanesession(self, numnodes, verbose=False, cls=None, values=None): """ Build a topology consisting of the given number of LxcNodes connected to an EMANE WLAN. """ prefix = ipaddress.Ipv4Prefix("10.0.0.0/16") self.session = Session(2) self.session.node_count = str(numnodes + 1) self.session.master = True self.session.location.setrefgeo(47.57917, -122.13232, 2.00000) self.session.location.refscale = 150.0 self.session.emane.loadmodels() self.net = self.session.add_object(cls=EmaneNode, objid=numnodes + 1, name="wlan1") self.net.verbose = verbose # self.session.emane.addobj(self.net) for i in xrange(1, numnodes + 1): addr = "%s/%s" % (prefix.addr(i), 32) tmp = self.session.add_object(cls=nodes.CoreNode, objid=i, name="n%d" % i) # tmp.setposition(i * 20, 50, None) tmp.setposition(50, 50, None) tmp.newnetif(self.net, [addr]) self.nodes.append(tmp) self.session.services.add_services(tmp, "router", "IPForward") if values is None: values = cls.getdefaultvalues() self.session.emane.setconfig(self.net.objid, cls.name, values) self.session.instantiate() self.info("waiting %s sec (TAP bring-up)" % 2) time.sleep(2) for i in xrange(1, numnodes + 1): tmp = self.nodes[i - 1] self.session.services.boot_services(tmp) self.staticroutes(i, prefix, numnodes) def setnodes(self): """ Set the sender and receiver nodes for use in this experiment, along with the address of the receiver to be used. """ self.firstnode = self.nodes[0] self.lastnode = self.nodes[-1] self.lastaddr = self.lastnode.netif(0).addrlist[0].split("/")[0] def staticroutes(self, i, prefix, numnodes): """ Add static routes on node number i to the other nodes in the chain. """ routecmd = ["/sbin/ip", "route", "add"] node = self.nodes[i - 1] neigh_left = "" neigh_right = "" # add direct interface routes first if i > 1: neigh_left = "%s" % prefix.addr(i - 1) cmd = routecmd + [neigh_left, "dev", node.netif(0).name] (status, result) = node.cmd_output(cmd) if status != 0: self.warn("failed to add interface route: %s" % cmd) if i < numnodes: neigh_right = "%s" % prefix.addr(i + 1) cmd = routecmd + [neigh_right, "dev", node.netif(0).name] (status, result) = node.cmd_output(cmd) if status != 0: self.warn("failed to add interface route: %s" % cmd) # add static routes to all other nodes via left/right neighbors for j in xrange(1, numnodes + 1): if abs(j - i) < 2: continue addr = "%s" % prefix.addr(j) if j < i: gw = neigh_left else: gw = neigh_right cmd = routecmd + [addr, "via", gw] (status, result) = node.cmd_output(cmd) if status != 0: self.warn("failed to add route: %s" % cmd) def setpathloss(self, numnodes): """ Send EMANE pathloss events to connect all NEMs in a chain. """ if self.session.emane.version < self.session.emane.EMANE091: service = emaneeventservice.EventService() e = emaneeventpathloss.EventPathloss(1) old = True else: if self.session.emane.version == self.session.emane.EMANE091: dev = "lo" else: dev = self.session.obj("ctrlnet").brname service = EventService(eventchannel=("224.1.2.8", 45703, dev), otachannel=None) old = False for i in xrange(1, numnodes + 1): rxnem = i # inform rxnem that it can hear node to the left with 10dB noise txnem = rxnem - 1 if txnem > 0: if old: e.set(0, txnem, 10.0, 10.0) service.publish(emaneeventpathloss.EVENT_ID, emaneeventservice.PLATFORMID_ANY, rxnem, emaneeventservice.COMPONENTID_ANY, e.export()) else: e = PathlossEvent() e.append(txnem, forward=10.0, reverse=10.0) service.publish(rxnem, e) # inform rxnem that it can hear node to the right with 10dB noise txnem = rxnem + 1 if txnem > numnodes: continue if old: e.set(0, txnem, 10.0, 10.0) service.publish(emaneeventpathloss.EVENT_ID, emaneeventservice.PLATFORMID_ANY, rxnem, emaneeventservice.COMPONENTID_ANY, e.export()) else: e = PathlossEvent() e.append(txnem, forward=10.0, reverse=10.0) service.publish(rxnem, e) def setneteffects(self, bw=None, delay=None): """ Set link effects for all interfaces attached to the network node. """ if not self.net: self.warn("failed to set effects: no network node") return for netif in self.net.netifs(): self.net.linkconfig(netif, bw=bw, delay=delay) def runalltests(self, title=""): """ Convenience helper to run all defined experiment tests. If tests are run multiple times, this returns the average of those runs. """ duration = self.opt.duration rate = self.opt.rate if len(title) > 0: self.info("----- running %s tests (duration=%s, rate=%s) -----" % \ (title, duration, rate)) (latency, mdev, throughput, cpu, loss) = (0, 0, 0, 0, 0) self.info("number of runs: ping=%d, iperf=%d, mgen=%d" % \ (self.numping, self.numiperf, self.nummgen)) if self.numping > 0: (latency, mdev) = self.pingtest(count=self.numping) if self.numiperf > 0: throughputs = [] for i in range(1, self.numiperf + 1): throughput = self.iperftest(time=duration) if self.numiperf > 1: throughputs += throughput # iperf is very CPU intensive time.sleep(1) if self.numiperf > 1: throughput = sum(throughputs) / len(throughputs) self.info("throughputs=%s" % ["%.2f" % v for v in throughputs]) if self.nummgen > 0: cpus = [] losses = [] for i in range(1, self.nummgen + 1): (cpu, loss) = self.cputest(time=duration, rate=rate) if self.nummgen > 1: cpus += cpu, losses += loss, if self.nummgen > 1: cpu = sum(cpus) / len(cpus) loss = sum(losses) / len(losses) self.info("cpus=%s" % ["%.2f" % v for v in cpus]) self.info("losses=%s" % ["%.2f" % v for v in losses]) return latency, mdev, throughput, cpu, loss def pingtest(self, count=50): """ Ping through a chain of nodes and report the average latency. """ p = PingCmd(node=self.firstnode, verbose=self.verbose, addr=self.lastaddr, count=count, interval=0.1).run() (latency, mdev) = p self.info("latency (ms): %.03f, %.03f" % (latency, mdev)) return p def iperftest(self, time=10): """ Run iperf through a chain of nodes and report the maximum throughput. """ bps = IperfCmd(node=self.lastnode, client_node=self.firstnode, verbose=False, addr=self.lastaddr, time=time).run() self.info("throughput (bps): %s" % bps) return bps def cputest(self, time=10, rate=512): """ Run MGEN through a chain of nodes and report the CPU usage and percent of lost packets. Rate is in kbps. """ if self.verbose: self.info("%s initial test ping (max 1 second)..." % \ self.firstnode.name) (status, result) = self.firstnode.cmd_output(["ping", "-q", "-c", "1", "-w", "1", self.lastaddr]) if status != 0: self.warn("initial ping from %s to %s failed! result:\n%s" % \ (self.firstnode.name, self.lastaddr, result)) return 0.0, 0.0 lines = readstat() cpustart = getcputimes(lines[0]) loss = MgenCmd(node=self.lastnode, client_node=self.firstnode, verbose=False, addr=self.lastaddr, time=time, rate=rate).run() lines = readstat() cpuend = getcputimes(lines[0]) percent = calculatecpu(cpustart, cpuend) self.info("CPU usage (%%): %.02f, %.02f loss" % (percent, loss)) return percent, loss
def __init__(self, persistent = False, duration=600): self.duration = duration self.nodes = ns.network.NodeContainer() self.mobhelper = ns.mobility.MobilityHelper() Session.__init__(self, persistent = persistent)
from core.challenge import Challenge, ChallengeMetadata from core.session import Session from flags import FlagGenerator FLAGS = FlagGenerator.generate_flags() class JackIt(Challenge): meta = ChallengeMetadata( challenge_id="jackit_game", name="Game Programming Challenge", description="2D Side-scrolling game where you modify code to win", price=0, value=153, flag="", sort_order=1, js_function="jackIt()" ) def __init__(self): super().__init__() self.solved = True self.purchased = True def check(self, answer): self.solved = True return True Session.register_challenge(JackIt)
def shifttext(self, shift, msg): msg = msg.strip().lower() data = [] for c in msg: if c.strip() and c in self.ALPHABET: data.append(self.ALPHABET[(self.ALPHABET.index(c) + shift) % 26]) else: data.append(c) output = ''.join(data) return output def check(self, answer): # Update will only change the message if the timer is expired self.update() if answer.strip().lower() == self.message.strip().lower(): self.num_solved += 1 if self.num_solved >= self.num_to_solve: self.solved = True else: # If they're not done, generate a new encrypted message self.generate_enc_message() return True # They have to get all 50 in a row correct self.reset() return False Session.register_challenge(Rot)
def shutdown(self): # TODO: the following line tends to segfault ns-3 (and therefore # core-daemon) ns.core.Simulator.Destroy() Session.shutdown(self)
async def first_checkin(self, GUID): data = json.loads(await request.data) self.dispatch_event(NEW_SESSION, Session(GUID, request.remote_addr, data)) return jsonify({}), 200
def main(): usagestr = "usage: %prog [-h] [options] [args]" parser = optparse.OptionParser(usage=usagestr) parser.set_defaults(waittime=0.2, numnodes=0, bridges=0, retries=0, logfile=None, services=None) parser.add_option("-w", "--waittime", dest="waittime", type=float, help="number of seconds to wait between node creation" \ " (default = %s)" % parser.defaults["waittime"]) parser.add_option("-n", "--numnodes", dest="numnodes", type=int, help="number of nodes (default = unlimited)") parser.add_option("-b", "--bridges", dest="bridges", type=int, help="number of nodes per bridge; 0 = one bridge " \ "(def. = %s)" % parser.defaults["bridges"]) parser.add_option("-r", "--retry", dest="retries", type=int, help="number of retries on error (default = %s)" % \ parser.defaults["retries"]) parser.add_option("-l", "--log", dest="logfile", type=str, help="log memory usage to this file (default = %s)" % \ parser.defaults["logfile"]) parser.add_option("-s", "--services", dest="services", type=str, help="pipe-delimited list of services added to each " "node (default = %s)\n(Example: zebra|OSPFv2|OSPFv3|" "IPForward)" % parser.defaults["services"]) def usage(msg=None, err=0): sys.stdout.write("\n") if msg: sys.stdout.write(msg + "\n\n") parser.print_help() sys.exit(err) options, args = parser.parse_args() for a in args: sys.stderr.write("ignoring command line argument: %s\n" % a) start = datetime.datetime.now() prefix = ipaddress.Ipv4Prefix("10.83.0.0/16") print "Testing how many network namespace nodes this machine can create." print " - %s" % linuxversion() mem = memfree() print " - %.02f GB total memory (%.02f GB swap)" % (mem["total"] / GBD, mem["stotal"] / GBD) print " - using IPv4 network prefix %s" % prefix print " - using wait time of %s" % options.waittime print " - using %d nodes per bridge" % options.bridges print " - will retry %d times on failure" % options.retries print " - adding these services to each node: %s" % options.services print " " lfp = None if options.logfile is not None: # initialize a csv log file header lfp = open(options.logfile, "a") lfp.write("# log from howmanynodes.py %s\n" % time.ctime()) lfp.write("# options = %s\n#\n" % options) lfp.write("# numnodes,%s\n" % ",".join(MEMKEYS)) lfp.flush() session = Session(1) switch = session.add_object(cls=nodes.SwitchNode) switchlist.append(switch) print "Added bridge %s (%d)." % (switch.brname, len(switchlist)) i = 0 retry_count = options.retries while True: i += 1 # optionally add a bridge (options.bridges nodes per bridge) try: if 0 < options.bridges <= switch.numnetif(): switch = session.add_object(cls=nodes.SwitchNode) switchlist.append(switch) print "\nAdded bridge %s (%d) for node %d." % (switch.brname, len(switchlist), i) except Exception, e: print "At %d bridges (%d nodes) caught exception:\n%s\n" % (len(switchlist), i - 1, e) break # create a node try: n = session.add_object(cls=nodes.LxcNode, name="n%d" % i) n.newnetif(switch, ["%s/%s" % (prefix.addr(i), prefix.prefixlen)]) n.cmd([constants.SYSCTL_BIN, "net.ipv4.icmp_echo_ignore_broadcasts=0"]) if options.services is not None: session.services.add_services(n, "", options.services.split("|")) session.services.boot_services(n) nodelist.append(n) if i % 25 == 0: print "\n%s nodes created " % i, mem = memfree() free = mem["free"] + mem["buff"] + mem["cached"] swap = mem["stotal"] - mem["sfree"] print "(%.02f/%.02f GB free/swap)" % (free / GBD, swap / GBD), if lfp: lfp.write("%d," % i) lfp.write("%s\n" % ",".join(str(mem[x]) for x in MEMKEYS)) lfp.flush() else: sys.stdout.write(".") sys.stdout.flush() time.sleep(options.waittime) except Exception, e: print "At %d nodes caught exception:\n" % i, e if retry_count > 0: print "\nWill retry creating node %d." % i shutil.rmtree(n.nodedir, ignore_errors=True) retry_count -= 1 i -= 1 time.sleep(options.waittime) continue else: print "Stopping at %d nodes!" % i break