def example(nodes):
# ip generator for example
prefixes = IpPrefixes("192.168.10.0/24")
node_list = []
# create emulator instance for creating sessions and utility methods
coreemu = globals().get("coreemu", CoreEmu())
session = coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create nodes
node_options = NodeOptions()
x = 0
for i in range(nodes):
node_options.set_position(x, 100)
x = x+70
session.add_node(node_options=node_options)
node_list.append(node)
# create switch network node
wlan = session.add_node(_type=NodeTypes.WIRELESS_LAN)
session.mobility.set_model(wlan, BasicRangeModel)
for node in node_list:
interface = prefixes.create_interface(node)
session.add_link(node.id, wlan.id, interface_one=interface)
# instantiate session
session.instantiate()
def example(options):
# ip generator for example
prefixes = IpPrefixes(ip4_prefix="10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu()
session = coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create emane network node
emane_network = session.create_emane_network(model=EmaneIeee80211abgModel,
geo_reference=(47.57917,
-122.13232,
2.00000))
emane_network.setposition(x=80, y=50)
# create nodes
for i in range(options.nodes):
node = session.create_wireless_node()
node.setposition(x=150 * (i + 1), y=150)
interface = prefixes.create_interface(node)
session.add_link(node.id, emane_network.id, interface_one=interface)
# instantiate session
session.instantiate()
# start a shell on the first node
node = session.get_node(2)
node.client.term("bash")
# shutdown session
input("press enter to exit...")
coreemu.shutdown()
def example(args):
# ip generator for example
prefixes = IpPrefixes(ip4_prefix="10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu()
session = coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create switch network node
switch = session.add_node(_type=NodeTypes.SWITCH)
# create nodes
for _ in range(args.nodes):
node = session.add_node()
interface = prefixes.create_interface(node)
session.add_link(node.id, switch.id, interface_one=interface)
# instantiate session
session.instantiate()
# get nodes to run example
first_node = session.get_node(2)
last_node = session.get_node(args.nodes + 1)
first_node_address = prefixes.ip4_address(first_node)
logging.info("node %s pinging %s", last_node.name, first_node_address)
output = last_node.cmd(f"ping -c {args.count} {first_node_address}")
logging.info(output)
# shutdown session
coreemu.shutdown()
def example(args):
# ip generator for example
prefixes = IpPrefixes(ip4_prefix="10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu()
session = coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create emane network node
session.set_location(47.57917, -122.13232, 2.00000, 1.0)
options = NodeOptions()
options.set_position(80, 50)
emane_network = session.add_node(_type=NodeTypes.EMANE, options=options)
session.emane.set_model(emane_network, EmaneIeee80211abgModel)
# create nodes
options = NodeOptions(model="mdr")
for i in range(args.nodes):
node = session.add_node(options=options)
node.setposition(x=150 * (i + 1), y=150)
interface = prefixes.create_interface(node)
session.add_link(node.id, emane_network.id, interface_one=interface)
# instantiate session
session.instantiate()
# shutdown session
input("press enter to exit...")
coreemu.shutdown()
def main(args):
# ip generator for example
prefixes = IpPrefixes(ip4_prefix="10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu({"distributed_address": args.address})
session = coreemu.create_session()
# initialize distributed
server_name = "core2"
session.distributed.add_server(server_name, args.server)
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create local node, switch, and remote nodes
options = NodeOptions()
node_one = session.add_node(options=options)
options.server = server_name
node_two = session.add_node(options=options)
# create node interfaces and link
interface_one = prefixes.create_interface(node_one)
interface_two = prefixes.create_interface(node_two)
session.add_link(node_one.id, node_two.id, interface_one, interface_two)
# instantiate session
session.instantiate()
# pause script for verification
input("press enter for shutdown")
# shutdown session
coreemu.shutdown()
def __init__(self, yml_nodes=None, yml_links=None, netmask="10.0.0.0/24"):
"""
Constructor for the Topology class - Creates a topology and starts the emulation, if no parameters were provided then an empty topolgy is created.
:param yml_nodes: a list containing the nodes parsed from the topology configuration file, defaults to None
:type yml_nodes: list(YML_node), optional
:param yml_links: a list containing the links parsed from the topology configuration file, defaults to None
:type yml_links: list(parser.YML_link), optional
:param netmask: the netmask tells the emulator what sort of IP addresses the virtual nodes should be assigned, defaults to 10.0.0.0/24
:type netmask: str
"""
Topology.prefixes = IpPrefixes(
ip4_prefix=netmask) #prefixes # CORE prefixes
self.coreemu = globals().get("coreemu",
CoreEmu()) # CORE container for sessions
self.session = self.coreemu.create_session() # CORE session
self.flag_physical_node = False
self.netmask = netmask
self.interfaceDict = {}
self.inter_nodes = [] # Nodes from coreNode types
self.physical_links = {}
self.list_physical_links = []
self.session.set_state(EventTypes.CONFIGURATION_STATE)
self.interNodeObjects = []
self.interLinkObjects = []
if (yml_nodes and yml_links):
self._init_topology(yml_nodes, yml_links)
else:
self.session.instantiate()
def __init__(self, ip4_prefix: str = None, ip6_prefix: str = None) -> None:
"""
Creates an InterfaceHelper object.
:param ip4_prefix: ip4 prefix to use for generation
:param ip6_prefix: ip6 prefix to use for generation
:raises ValueError: when both ip4 and ip6 prefixes have not been provided
"""
self.prefixes = IpPrefixes(ip4_prefix, ip6_prefix)
def __init__(self, env_config, silent=True):
if not silent:
load_logging_config()
self.envParser = EnvParser(env_config)
if self.envParser.ip4_prefix:
self.prefix = IpPrefixes(ip4_prefix=self.envParser.ip4_prefix)
else:
self.prefix = IpPrefixes(ip6_prefix=self.envParser.ip6_prefix)
self.nodes = {} # pc nodes
self.networks = [] # switches nodes
# create emulator instance for creating sessions and utility methods
self.coreemu = CoreEmu()
self.session = self.coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
self.session.set_state(EventTypes.CONFIGURATION_STATE)
# create nodes
for node in self.envParser.nodes:
self.nodes[int(node["id"])] = {"obj": self.session.add_node(_type=NodeTypes.DEFAULT), "nets": [],
"ip": None, "curr_net": None}
# create networks
for net in self.envParser.networks:
self.networks.append(self.session.add_node(_type=NodeTypes.SWITCH))
for node in net["nodes"]:
interface = self.prefix.create_interface(self.nodes[node["id"]]["obj"],
name=self.envParser.dev_prefix + str(net["id"]))
self.nodes[node["id"]]["ip"] = self.prefix.ip4_address(self.nodes[node["id"]]["obj"])
self.session.add_link(self.nodes[node["id"]]["obj"].id, self.networks[-1].id, interface_one=interface)
self.nodes[node["id"]]["nets"].append({
"net": net["id"]
})
# certs
shutil.rmtree('certs', True)
self.__create_root_ca()
for node in self.nodes:
self.__create_node_cert(node)
# instantiate session
self.start()
def main():
# ip generator for example
prefixes = IpPrefixes(ip4_prefix="10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu()
session = coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create emane network node, emane determines connectivity based on
# location, so the session and nodes must be configured to provide one
session.set_location(47.57917, -122.13232, 2.00000, 1.0)
options = NodeOptions()
options.set_position(80, 50)
emane_network = session.add_node(_type=NodeTypes.EMANE,
options=options,
_id=100)
session.emane.set_model(emane_network, EmaneIeee80211abgModel)
# create nodes
options = NodeOptions(model="mdr")
for i in range(NODES):
node = session.add_node(options=options)
node.setposition(x=150 * (i + 1), y=150)
interface = prefixes.create_interface(node)
session.add_link(node.id, emane_network.id, interface_one=interface)
# instantiate session
session.instantiate()
# OSPF MDR requires some time for routes to be created
logging.info("waiting %s seconds for OSPF MDR to create routes",
EMANE_DELAY)
time.sleep(EMANE_DELAY)
# get nodes to run example
first_node = session.get_node(1)
last_node = session.get_node(NODES)
address = prefixes.ip4_address(first_node)
logging.info("node %s pinging %s", last_node.name, address)
output = last_node.cmd(f"ping -c 3 {address}")
logging.info(output)
# shutdown session
coreemu.shutdown()
def main(args):
# ip generator for example
prefixes = IpPrefixes(ip4_prefix="10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu(
{
"controlnet": "core1:172.16.1.0/24 core2:172.16.2.0/24 core3:172.16.3.0/24 "
"core4:172.16.4.0/24 core5:172.16.5.0/24",
"distributed_address": args.address,
}
)
session = coreemu.create_session()
# initialize distributed
server_name = "core2"
session.distributed.add_server(server_name, args.server)
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create local node, switch, and remote nodes
options = NodeOptions(model="mdr")
options.set_position(0, 0)
node_one = session.add_node(options=options)
emane_net = session.add_node(_type=NodeTypes.EMANE)
session.emane.set_model(emane_net, EmaneIeee80211abgModel)
options.server = server_name
node_two = session.add_node(options=options)
# create node interfaces and link
interface_one = prefixes.create_interface(node_one)
interface_two = prefixes.create_interface(node_two)
session.add_link(node_one.id, emane_net.id, interface_one=interface_one)
session.add_link(node_two.id, emane_net.id, interface_one=interface_two)
# instantiate session
session.instantiate()
# pause script for verification
input("press enter for shutdown")
# shutdown session
coreemu.shutdown()
def example(options):
# ip generator for example
prefixes = IpPrefixes("10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu()
session = coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create wlan network node
wlan = session.add_node(_type=NodeTypes.WIRELESS_LAN)
session.set_wireless_model(wlan, BasicRangeModel)
# create nodes
wireless_nodes = []
for _ in xrange(options.nodes):
node = session.add_node()
interface = prefixes.create_interface(node)
session.add_link(node.objid, wlan.objid, interface_one=interface)
wireless_nodes.append(node)
# link all created nodes with the wireless network
session.wireless_link_all(wlan, wireless_nodes)
# instantiate session
session.instantiate()
# get nodes for example run
first_node = session.get_object(2)
last_node = session.get_object(options.nodes + 1)
print "starting iperf server on node: %s" % first_node.name
first_node.cmd(["iperf", "-s", "-D"])
address = prefixes.ip4_address(first_node)
print "node %s connecting to %s" % (last_node.name, address)
last_node.client.icmd(["iperf", "-t", str(options.time), "-c", address])
first_node.cmd(["killall", "-9", "iperf"])
# shutdown session
coreemu.shutdown()
def example(args):
# ip generator for example
prefixes = IpPrefixes("10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu()
session = coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create wlan network node
wlan = session.add_node(_type=NodeTypes.WIRELESS_LAN)
session.mobility.set_model(wlan, BasicRangeModel)
# create nodes, must set a position for wlan basic range model
options = NodeOptions(model="mdr")
options.set_position(0, 0)
for _ in range(args.nodes):
node = session.add_node(options=options)
interface = prefixes.create_interface(node)
session.add_link(node.id, wlan.id, interface_one=interface)
# instantiate session
session.instantiate()
# get nodes for example run
first_node = session.get_node(2)
last_node = session.get_node(args.nodes + 1)
logging.info("starting iperf server on node: %s", first_node.name)
first_node.cmd("iperf -s -D")
address = prefixes.ip4_address(first_node)
logging.info("node %s connecting to %s", last_node.name, address)
output = last_node.cmd(f"iperf -t {args.time} -c {address}")
logging.info(output)
first_node.cmd("killall -9 iperf")
# shutdown session
coreemu.shutdown()
def example(nodes):
# ip generator for example
prefixes = IpPrefixes("10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = globals()["coreemu"]
session = coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create switch network node
switch = session.add_node(_type=NodeTypes.SWITCH)
# create nodes
for _ in range(nodes):
node = session.add_node()
interface = prefixes.create_interface(node)
session.add_link(node.id, switch.id, interface_one=interface)
# instantiate session
session.instantiate()
def example(options):
# ip generator for example
prefixes = IpPrefixes("10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu()
session = coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create wlan network node
wlan = session.add_node(_type=NodeTypes.WIRELESS_LAN)
session.mobility.set_model(wlan, BasicRangeModel)
# create nodes, must set a position for wlan basic range model
node_options = NodeOptions()
node_options.set_position(0, 0)
for _ in range(options.nodes):
node = session.add_node(node_options=node_options)
interface = prefixes.create_interface(node)
session.add_link(node.id, wlan.id, interface_one=interface)
# instantiate session
session.instantiate()
# get nodes for example run
first_node = session.get_node(2)
last_node = session.get_node(options.nodes + 1)
print("starting iperf server on node: %s" % first_node.name)
first_node.cmd(["iperf", "-s", "-D"])
address = prefixes.ip4_address(first_node)
print("node %s connecting to %s" % (last_node.name, address))
last_node.client.icmd(["iperf", "-t", str(options.time), "-c", address])
first_node.cmd(["killall", "-9", "iperf"])
# shutdown session
coreemu.shutdown()
def example(options):
# ip generator for example
prefixes = IpPrefixes(ip4_prefix="10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu()
session = coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create switch network node
switch = session.add_node(_type=NodeTypes.SWITCH)
# create nodes
for _ in range(options.nodes):
node = session.add_node()
interface = prefixes.create_interface(node)
session.add_link(node.id, switch.id, interface_one=interface)
# instantiate session
session.instantiate()
# get nodes to run example
first_node = session.get_node(2)
last_node = session.get_node(options.nodes + 1)
print("starting iperf server on node: %s" % first_node.name)
first_node.cmd(["iperf", "-s", "-D"])
first_node_address = prefixes.ip4_address(first_node)
print("node %s connecting to %s" % (last_node.name, first_node_address))
last_node.client.icmd(
["iperf", "-t",
str(options.time), "-c", first_node_address])
first_node.cmd(["killall", "-9", "iperf"])
# shutdown session
coreemu.shutdown()
def example(nodes):
# ip generator for example
prefixes = IpPrefixes("192.168.10.0/24")
node_list = []
# create emulator instance for creating sessions and utility methods
core_emu = globals().get("coreemu", CoreEmu())
session = core_emu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create nodes
node_options = NodeOptions()
x = 0
for i in range(nodes):
y = 200
x = x + 100
if (i - 1) % 2 == 0: #node id starts at 1
y = 400
node_options.set_position(x, y)
node = session.add_node(node_options=node_options)
node_list.append(node)
# create switch network node
wlan = session.add_node(_type=NodeTypes.WIRELESS_LAN)
session.mobility.set_model(wlan, BasicRangeModel)
for node in node_list:
interface = prefixes.create_interface(node)
session.add_link(node.id, wlan.id, interface_one=interface)
# instantiate session
session.instantiate()
for node_num in range(2, 2 + nodes - 1):
n = session.get_node(node_num)
print("starting swarmdag on node: %s" % n.name)
n.cmd([swarmdag_path, ">", "swarmdag.txt"])
def main():
# ip generator for example
prefixes = IpPrefixes("10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu()
session = coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create wlan network node
wlan = session.add_node(WlanNode, _id=100)
session.mobility.set_model(wlan, BasicRangeModel)
# create nodes, must set a position for wlan basic range model
options = NodeOptions(model="mdr")
options.set_position(0, 0)
for _ in range(NODES):
node = session.add_node(CoreNode, options=options)
interface = prefixes.create_interface(node)
session.add_link(node.id, wlan.id, interface_one=interface)
# instantiate session
session.instantiate()
# get nodes for example run
first_node = session.get_node(1, CoreNode)
last_node = session.get_node(NODES, CoreNode)
address = prefixes.ip4_address(first_node)
logging.info("node %s pinging %s", last_node.name, address)
output = last_node.cmd(f"ping -c 3 {address}")
logging.info(output)
# shutdown session
coreemu.shutdown()
dst_address = prefixes.ip4_address(destination)
print "Starting iperf to %s" % str(dst_address)
destination.cmd(["iperf", "-s", "-D"])
source.client.icmd(["iperf", "-t", "10", "-c", dst_address])
destination.cmd(["killall", "-9", "iperf"])
if __name__ == '__main__':
framework.start()
print "Starting Experiment"
# ip generator for example
prefixes = IpPrefixes(ip4_prefix="10.83.0.0/16")
# create emulator instance for creating sessions and utility methods
coreemu = CoreEmu()
session = coreemu.create_session()
# must be in configuration state for nodes to start, when using "node_add" below
session.set_state(EventTypes.CONFIGURATION_STATE)
# create switch network node
switch = session.add_node(_type=NodeTypes.SWITCH)
print "Everything is set up now."
# create nodes
for _ in xrange(2):
def ip_prefixes():
return IpPrefixes(ip4_prefix="10.83.0.0/16")
def network_initializer(self, switches, composition, attackers):
# check that switches is 2 <= s <= 10
if (2 <= switches and switches <= 10):
return "Error: Can only initalize a network of 2 to 10 switches in size"
# ip generator
prefixes = IpPrefixes(ip4_prefix="10.42.0.0/16")
# create emulator instance for creating sessions and utility methods
cli = False
coreemu = globals().get("coreemu")
# if not using the GUI provide path to the custom services directory
if not coreemu:
config = {"custom_services_dir": "../canaryServices"}
coreemu = CoreEmu(config=config)
cli = True
session = coreemu.create_session()
# create client node options
node_options = NodeOptions()
node_options.services = ["Node"]
# create attacker node options
attacker_options = NodeOptions()
attacker_options.services = ["Attacker"]
# must be in configuration state for nodes to start, when using
# "add_node" below
session.set_state(EventTypes.CONFIGURATION_STATE)
node = []
switch = []
i = 0
# create switches
for _ in range(switches):
y = random.randint(200, 700)
x = random.randint(200, 700)
switch.append(session.add_node(_type=NodeTypes.SWITCH))
switch[i].setposition(x=x, y=y)
i = i + 1
# create list of randomly selected nodes for attacker deployment
nodes = []
if (attackers == "-1"):
print("Generating attacker list...")
for _ in range(switches * 5):
while (True):
rnd = random.randint(0, switches * 5)
if (rnd not in nodes):
nodes.append(rnd)
break
slc = (len(nodes) * composition)
attackers = nodes[:int(slc)]
else:
nodes = [i for i in range(switches * 5)]
if (attackers):
attackers = attackers.split(',')
attackers = [int(i) for i in attackers]
else:
attackers = []
print("Nodes: " + str(nodes))
print("Attackers: " + str(attackers))
i = 0
# create client nodes
for _ in range(switches * 5):
y = random.randint(150, 750)
x = random.randint(150, 750)
if (i in attackers):
node.append(session.add_node(node_options=attacker_options))
else:
node.append(session.add_node(node_options=node_options))
node[i].setposition(x=x, y=y)
node_interface = prefixes.create_interface(node[i])
# create interfaces to connect client nodes to switches
if (i % switches == 0):
switch_interface = prefixes.create_interface(switch[0])
session.add_link(node[i].id, switch[0].id, node_interface,
switch_interface)
elif (i % switches == 1):
switch_interface = prefixes.create_interface(switch[1])
session.add_link(node[i].id, switch[1].id, node_interface,
switch_interface)
elif (i % switches == 2):
switch_interface = prefixes.create_interface(switch[2])
session.add_link(node[i].id, switch[2].id, node_interface,
switch_interface)
elif (i % switches == 3):
switch_interface = prefixes.create_interface(switch[3])
session.add_link(node[i].id, switch[3].id, node_interface,
switch_interface)
elif (i % switches == 4):
switch_interface = prefixes.create_interface(switch[4])
session.add_link(node[i].id, switch[4].id, node_interface,
switch_interface)
elif (i % switches == 5):
switch_interface = prefixes.create_interface(switch[5])
session.add_link(node[i].id, switch[5].id, node_interface,
switch_interface)
elif (i % switches == 6):
switch_interface = prefixes.create_interface(switch[6])
session.add_link(node[i].id, switch[6].id, node_interface,
switch_interface)
elif (i % switches == 7):
switch_interface = prefixes.create_interface(switch[7])
session.add_link(node[i].id, switch[7].id, node_interface,
switch_interface)
elif (i % switches == 8):
switch_interface = prefixes.create_interface(switch[8])
session.add_link(node[i].id, switch[8].id, node_interface,
switch_interface)
elif (i % switches == 9):
switch_interface = prefixes.create_interface(switch[9])
session.add_link(node[i].id, switch[9].id, node_interface,
switch_interface)
i = i + 1
# create interfaces to connect switches
if (switches >= 2):
switch_a = prefixes.create_interface(switch[0])
switch_b = prefixes.create_interface(switch[1])
session.add_link(switch[0].id, switch[1].id, switch_a, switch_b)
if (switches >= 3):
switch_a = prefixes.create_interface(switch[1])
switch_b = prefixes.create_interface(switch[2])
session.add_link(switch[1].id, switch[2].id, switch_a, switch_b)
if (switches >= 4):
switch_a = prefixes.create_interface(switch[2])
switch_b = prefixes.create_interface(switch[3])
session.add_link(switch[2].id, switch[3].id, switch_a, switch_b)
if (switches >= 5):
switch_a = prefixes.create_interface(switch[3])
switch_b = prefixes.create_interface(switch[4])
session.add_link(switch[3].id, switch[4].id, switch_a, switch_b)
if (switches >= 6):
switch_a = prefixes.create_interface(switch[4])
switch_b = prefixes.create_interface(switch[5])
session.add_link(switch[4].id, switch[5].id, switch_a, switch_b)
if (switches >= 7):
switch_a = prefixes.create_interface(switch[5])
switch_b = prefixes.create_interface(switch[6])
session.add_link(switch[5].id, switch[6].id, switch_a, switch_b)
if (switches >= 8):
switch_a = prefixes.create_interface(switch[6])
switch_b = prefixes.create_interface(switch[7])
session.add_link(switch[6].id, switch[7].id, switch_a, switch_b)
if (switches >= 9):
switch_a = prefixes.create_interface(switch[7])
switch_b = prefixes.create_interface(switch[8])
session.add_link(switch[7].id, switch[8].id, switch_a, switch_b)
if (switches >= 10):
switch_a = prefixes.create_interface(switch[8])
switch_b = prefixes.create_interface(switch[9])
session.add_link(switch[8].id, switch[9].id, switch_a, switch_b)
# instantiate session
session.instantiate()
print("Session Instantiated, CLI = " + str(cli))
# if the cli is being used terminate the session after 360 (canaries
# terminate after 340 + 20 seccond initalization delay) seconds
if (cli):
stop_time = datetime.datetime.now() + datetime.timedelta(0, 360)
while datetime.datetime.now() < stop_time:
pass
coreemu.delete_session(session.id)
print("Session Terminated by Timer")
def main():
# ip generator
prefixes = IpPrefixes(ip4_prefix="10.42.0.0/16")
# create emulator instance for creating sessions and utility methods
cli = False
coreemu = globals().get("coreemu")
if not coreemu:
config = {"custom_services_dir": "/home/whoward3/coreScripts/myServices"}
coreemu = CoreEmu(config=config)
cli = True
session = coreemu.create_session()
# create client node options
nodeOptions = NodeOptions()
nodeOptions.services = ["Node"]
# create attacker node options
attackerOptions = NodeOptions()
attackerOptions.services = ["Attacker"]
# must be in configuration state for nodes to start, when using "add_node" below
session.set_state(EventTypes.CONFIGURATION_STATE)
switches = 5 #random.randint(2,10)
node = []
switch = []
i = 0
# create switches
for _ in range(switches):
y = random.randint(200,700)
x = random.randint(200,700)
switch.append(session.add_node(_type=NodeTypes.SWITCH))
switch[i].setposition(x=x,y=y)
i=i+1
i = 0
# create client nodes
for _ in range(switches*5):
y = random.randint(150,750)
x = random.randint(150,750)
if(i % 3 == 0 and i < (switches*5)):
node.append(session.add_node(node_options=nodeOptions))
else:
node.append(session.add_node(node_options=nodeOptions))
node[i].setposition(x=x,y=y)
nodeInterface = prefixes.create_interface(node[i])
# create interfaces to connect client nodes to switches
if(i%switches==0):
routerInterface = prefixes.create_interface(switch[0])
session.add_link(node[i].id, switch[0].id, nodeInterface, routerInterface)
elif(i%switches==1):
routerInterface = prefixes.create_interface(switch[1])
session.add_link(node[i].id, switch[1].id, nodeInterface, routerInterface)
elif(i%switches==2):
routerInterface = prefixes.create_interface(switch[2])
session.add_link(node[i].id, switch[2].id, nodeInterface, routerInterface)
elif(i%switches==3):
routerInterface = prefixes.create_interface(switch[3])
session.add_link(node[i].id, switch[3].id, nodeInterface, routerInterface)
elif(i%switches==4):
routerInterface = prefixes.create_interface(switch[4])
session.add_link(node[i].id, switch[4].id, nodeInterface, routerInterface)
elif(i%switches==5):
routerInterface = prefixes.create_interface(switch[5])
session.add_link(node[i].id, switch[5].id, nodeInterface, routerInterface)
elif(i%switches==6):
routerInterface = prefixes.create_interface(switch[6])
session.add_link(node[i].id, switch[6].id, nodeInterface, routerInterface)
elif(i%switches==7):
routerInterface = prefixes.create_interface(switch[7])
session.add_link(node[i].id, switch[7].id, nodeInterface, routerInterface)
elif(i%switches==8):
routerInterface = prefixes.create_interface(switch[8])
session.add_link(node[i].id, switch[8].id, nodeInterface, routerInterface)
elif(i%switches==9):
routerInterface = prefixes.create_interface(switch[9])
session.add_link(node[i].id, switch[9].id, nodeInterface, routerInterface)
i=i+1
# create interfaces to connect switches
if(switches >= 2):
switchA = prefixes.create_interface(switch[0])
switchB = prefixes.create_interface(switch[1])
session.add_link(switch[0].id,switch[1].id,switchA,switchB)
if(switches >= 3):
switchA = prefixes.create_interface(switch[1])
switchB = prefixes.create_interface(switch[2])
session.add_link(switch[1].id,switch[2].id,switchA,switchB)
if(switches >= 4):
switchA = prefixes.create_interface(switch[2])
switchB = prefixes.create_interface(switch[3])
session.add_link(switch[2].id,switch[3].id,switchA,switchB)
if(switches >= 5):
switchA = prefixes.create_interface(switch[3])
switchB = prefixes.create_interface(switch[4])
session.add_link(switch[3].id,switch[4].id,switchA,switchB)
if(switches >= 6):
switchA = prefixes.create_interface(switch[4])
switchB = prefixes.create_interface(switch[5])
session.add_link(switch[4].id,switch[5].id,switchA,switchB)
if(switches >= 7):
switchA = prefixes.create_interface(switch[5])
switchB = prefixes.create_interface(switch[6])
session.add_link(switch[5].id,switch[6].id,switchA,switchB)
if(switches >= 8):
switchA = prefixes.create_interface(switch[6])
switchB = prefixes.create_interface(switch[7])
session.add_link(switch[6].id,switch[7].id,switchA,switchB)
if(switches >= 9):
switchA = prefixes.create_interface(switch[7])
switchB = prefixes.create_interface(switch[8])
session.add_link(switch[7].id,switch[8].id,switchA,switchB)
if(switches >= 10):
switchA = prefixes.create_interface(switch[8])
switchB = prefixes.create_interface(switch[9])
session.add_link(switch[8].id,switch[9].id,switchA,switchB)
# instantiate session
session.instantiate()
print("Session Instantiated, CLI = "+str(cli))
# if the cli is being used terminate the session after 360 (canaries terminate after 340 + 20 seccond initalization delay) secconds
if(cli):
stop_time = datetime.datetime.now() + datetime.timedelta(0,360)
while datetime.datetime.now() < stop_time:
pass
coreemu.delete_session(session.id)
print("Session Terminated by Timer")