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 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 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 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 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."
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()
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
