def __init__(self, sparkle):
"""Call parent constructors."""
VirtManager.__init__(self)
ModelManager.__init__(self, sparkle)
UdevManager.__init__(self)
NetworkManager.__init__(self)
def main():
config = Config()
controller = Controller(config)
net_man = NetworkManager(epochs=config.CNN_epochs,\
child_batchsize=128, lr=config.CNN_lr, momentum=0.9, acc_beta=0.8)
for i in range(config.max_no_of_sampled_networks):
print('sampling ', i, 'th network')
action = controller.get_action()
print(action)
sys.stdout.flush()
while convertToString(action) in reward_dict:
action = controller.get_action()
acc, flops, params = net_man.get_peformance_statistics(action)
reward_dict[convertToString(action)] = (acc, flops, params)
completed_action_list.append(action)
with open('completed_action_list.pickle', 'wb') as handle:
pickle.dump(completed_action_list,
handle,
protocol=pickle.HIGHEST_PROTOCOL)
with open('reward_dict.pickle', 'wb') as handle:
pickle.dump(reward_dict, handle, protocol=pickle.HIGHEST_PROTOCOL)
controller.train_step(reward_dict, completed_action_list)
controller.save_model()
def __init__(self, channeltype, band):
''' Get encoder and pass it to NetworkManager '''
self._channeltype = channeltype
self._band = band
encoder = MessageEncoderFactory.create(channeltype, band)
self._encoder = encoder
if not encoder:
raise Error('Such encoder does not exist')
self._netmanager = NetworkManager(encoder)
self._buffer = ('', None)
def setup_network_manager(self, k=None, edges=None):
'''Set the protocol to run when run_one_step or run_n_steps is called.'''
if k is None and edges is None:
raise ValueError("Either k or edges must be specified.")
# If k is not set then it defaults to the maximum node uid in edges.
if k is None:
k = max([max((a, b) for a, b in edges)])
self.network_manager = NetworkManager(self.cchl, edges)
self.reset()
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.setupUi(self)
# Create the name manager instance and move it to another thread.
# This will cause all the slots to be run in that other thread
# instead of our GUI thread.
self.name_manager = NameManager()
self.name_manager_thread = QThread()
self.name_manager.moveToThread(self.name_manager_thread)
self.name_manager_thread.start()
# Create our network manager
self.network_manager = NetworkManager()
# When the name manager emits it's full name list, we want to
# repopulate our list.
self.name_manager.names_signal.connect(self.populate_list)
# When the restore list button is clicked, let the name manager
# know we need all the names in long term storage
self.restore_list_button.clicked.connect(self.name_manager.get_all_names)
self.add_name_signal.connect(self.name_manager.store_name)
self.add_name_signal.connect(self.cache_name)
self.submit_button.clicked.connect(self.say_hello)
self.clear_list_button.clicked.connect(self.clear_list)
def __init__(self,networkmanager=None):
if(networkmanager == None):
self.nm = NetworkManager()
else:
self.nm = networkmanager
self.dm = DockerManager(self.nm.selected_machine["compute_id"])
pass
def __init__(self, networkManager=None, haveNat=False):
if networkManager is None:
self.nm = NetworkManager()
else:
self.nm = networkManager
self.dm = DockerManager(self.nm.selected_machine["compute_id"])
self.list_pcs = []
self.nat = None
self.flag_have_nat = haveNat
self.switch_lan = None
self.switch_services = None
self.switch_out = None
self.list_services = []
self.net_config_dhcp = '''# DHCP
def serve():
server = grpc.server(futures.ThreadPoolExecutor(max_workers=50))
greet_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
network_manager_pb2_grpc.add_NetworkManagerServicer_to_server(NetworkManager(), server)
server.add_insecure_port("[::]:" + str(globals.port))
logger.info("Server starting at port " + str(globals.port))
server.start()
server.wait_for_termination()
def serve():
server = grpc.server(futures.ThreadPoolExecutor(max_workers=50))
greet_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
network_manager_pb2_grpc.add_NetworkManagerServicer_to_server(
NetworkManager(), server)
traversal_pb2_grpc.add_TraversalServicer_to_server(Traversal(), server)
server.add_insecure_port("[::]:" + str(globals.port))
logger.info("Server starting at port " + str(globals.port))
storage_pb2_grpc.add_FileServerServicer_to_server(globals.storage_object,
server)
server.add_insecure_port("[::]:" + str(globals.port))
logger.info("Server starting at port " + str(globals.port))
replication_pb2_grpc.add_FileserviceServicer_to_server(
ReplicationService(), server)
server.start()
server.wait_for_termination()
class DgramSocket(object):
#----------------------------------------------------------------------------------
'''
This class represents datagram socket. Handles sending and buffered recept-
ion. Other calls are forwarded to NetworkManager.
'''
#----------------------------------------------------------------------------------
def __init__(self, channeltype, band):
''' Get encoder and pass it to NetworkManager '''
self._channeltype = channeltype
self._band = band
encoder = MessageEncoderFactory.create(channeltype, band)
self._encoder = encoder
if not encoder:
raise Error('Such encoder does not exist')
self._netmanager = NetworkManager(encoder)
self._buffer = ('', None)
#----------------------------------------------------------------------------------
def __del__(self):
del self._netmanager
del self._buffer
#----------------------------------------------------------------------------------
def setblocking(self, value):
'''
Sets socket to blocking/non-blocking/timeout mode. Default is blocking
mode.
'''
if value not in [0, 1, 2]:
raise Error('Illegal blocking argument: ' + str(value))
self._netmanager.setblocking(value)
#----------------------------------------------------------------------------------
def setactive(self, value):
''' Sets socket passive or active '''
if value:
value = 1
self._netmanager.setactive(value)
#----------------------------------------------------------------------------------
def bind(self, addr):
'''
Binds socket to given host and port. Fails if same port is already bou-
nd or if privileges are insufficient. NFQueue loop is run in child pro-
cces. addr is a tuple (host, port). Localhost is denoted by empty
string (' ').
'''
if len(addr) < 2:
raise Error('Invalid argument')
try:
if self._encoder.initpackets():
self._encoder = MessageEncoderFactory.create(self._channeltype,
self._band )
self._netmanager.bind(addr)
except gaierror, e:
raise Error('Given hostname or addres is not valid: ' + str(e))
class QKDProtocol:
def __init__(self, k=None, edges=None, check_bit_prob=0.2, protocol_id=0):
self.cchl = components.ClassicalChannel()
self.setup_network_manager(k, edges)
self.check_bit_prob = check_bit_prob
self.eavesdropping = False
self.intercepted_edges = []
self.computation_time = None
self.memory_usage = None
def reset(self):
'''Reset the protocol to its configuration at timestep 0.'''
self.timestep = 0
self.num_iterations = 0
self.num_generated_states = 0
self.security = 0
self.key_length = 0
self.stored_data = {}
self.cchl.reset()
self.network_manager.reset()
self.protocol_secure = True
self.next_timestep()
def setup_network_manager(self, k=None, edges=None):
'''Set the protocol to run when run_one_step or run_n_steps is called.'''
if k is None and edges is None:
raise ValueError("Either k or edges must be specified.")
# If k is not set then it defaults to the maximum node uid in edges.
if k is None:
k = max([max((a, b) for a, b in edges)])
self.network_manager = NetworkManager(self.cchl, edges)
self.reset()
def add_eavesdropping(self, edges):
'''Add eavesdropping to the specified edges.'''
self.network_manager.intercept_edges(edges, self.cchl)
self.eavesdropping = True
self.intercepted_edges = edges
def next_timestep(self):
'''Store the data from this timestep and set up for the next timestep.'''
self.cchl.next_timestep()
self.network_manager.next_timestep()
self.stored_data[self.num_iterations] = {
"security": self.security,
"key_length": self.key_length
}
self.timestep += 1
def store_timestep_data(self):
'''Store the data from this timestep.'''
self.cchl.store_timestep_data()
self.network_manager.store_timestep_data()
self.stored_data[self.num_iterations] = {
"security": self.security,
"key_length": self.key_length
}
def get_stored_data_for_timestep(self, timestep):
'''Retrieve all of the stored data for a given timestep.'''
stored_data = {
"protocol": copy.deepcopy(self.stored_data[timestep]),
"cchl": self.cchl.get_stored_data_for_timestep(timestep),
"parties": self.network_manager.get_party_stored_data_for_timestep(timestep),
"qchls": self.network_manager.get_qchl_stored_data_for_timestep(timestep)
}
return stored_data
def run_one_step(self, display_data=True):
'''Run one iteration of the set protocol.'''
if self.protocol_secure:
# Run one iteration of the set protocol.
protocol_secure = self.protocol()
# If eavesdropping was detected in this run of the protocol, then
# prevent any future attempts to run an iteration of the protocol.
self.protocol_secure = protocol_secure
# Optionally print the data to the terminal.
if display_data:
self.display_data()
# Setup for the next timestep.
if self.protocol_secure:
self.next_timestep()
else:
self.store_timestep_data()
# Update the security and the key length fields
self.update_security()
self.update_key_length()
# Increment the iteration counter.
self.num_iterations += 1
def run_n_steps(self, n, display_bits=True):
'''Run n iterations of the protocol.'''
if self.protocol_secure:
count = 0
while self.protocol_secure and count < n:
self.run_one_step(display_data=False)
count += 1
self.display_data(display_bits)
def run(self, num_iterations=None, security=0.95, key_length=128):
'''Run for the given number of iterations, or until the secret key reaches the required length.'''
# If the number of iterations is explicitly specified, then run the
# protocol for exactly this number of iterations.
if num_iterations is not None:
self.run_n_steps(num_iterations)
# Otherwise, continue to run the protocol until the secret key reaches
# the required length and enough bits have been used as check bits to
# provide the required level of security.
else:
# Calculate the minimum number of check bits
required_num_check_bits = self.required_num_check_bits(security)
# Run the protocol until the required number of check bits and
# key bits is reached.
num_check_bits = self.get_shortest_check_bits()
num_key_bits = self.get_shortest_key_length()
while self.protocol_secure and (num_key_bits < key_length or
num_check_bits < required_num_check_bits):
self.run_one_step(display_data=False)
num_check_bits = self.get_shortest_check_bits()
num_key_bits = self.get_shortest_key_length()
def required_num_check_bits(self, security):
'''Calculate the minimum number of check bits required for the given security level.'''
return math.ceil(math.log(1 - security) / math.log(0.75))
def get_shortest_key_length(self):
'''Return the length of the shortest secret key in the network.'''
# TODO Move this to NetworkManager
parties = self.network_manager.get_parties()
min_key_length = math.inf
for uidA in parties:
partyA = parties[uidA]
secret_keys = partyA.secret_keys
if not secret_keys:
min_key_length = 0
break
secret_keys_by_uid = shared_fns.reorder_by_uid(secret_keys)
for uidB in secret_keys_by_uid:
key_length = len(list(secret_keys_by_uid[uidB]))
if key_length < min_key_length:
min_key_length = key_length
return min_key_length
def get_shortest_check_bits(self):
'''Return the length of the shortest check bits in the network.'''
# TODO Move this to NetworkManager
parties = self.network_manager.get_parties()
min_check_bits = math.inf
for uidA in parties:
partyA = parties[uidA]
check_bits = partyA.check_bits
if not check_bits:
min_check_bits = 0
break
check_bits_by_uid = shared_fns.reorder_by_uid(check_bits)
for uidB in check_bits_by_uid:
key_length = len(list(check_bits_by_uid[uidB]))
if key_length < min_check_bits:
min_check_bits = key_length
return min_check_bits
def update_key_length(self):
self.key_length = self.get_shortest_key_length()
def update_security(self):
# Given n matching check bits, calculate the least upper bound for the
# probability that Eve has gotten away with eavesdropping.
num_check_bits = self.get_shortest_check_bits()
security = 0
upper_bound = 1
while upper_bound - security > 0.0001:
candidate = security + (upper_bound - security) / 2
n = self.required_num_check_bits(candidate)
if n > num_check_bits:
upper_bound = candidate
elif n <= num_check_bits:
security = candidate
self.security = security
def calculate_qubit_counts(self):
'''
Sum the qubit counts for all the parties in the network.
Calculate how many qubits have been generated, transmitted and
received in total across the entire network.
:return: a tuple of the three qubit totals
'''
total_qstates_generated = 0
total_qstates_transmitted = 0
total_qstates_received = 0
parties = self.network_manager.get_parties()
for party_uid in parties:
party = parties[party_uid]
total_qstates_generated += party.total_qstates_generated
total_qstates_transmitted += party.total_qstates_transmitted
total_qstates_received += party.total_qstates_received
return (total_qstates_generated,
total_qstates_transmitted,
total_qstates_received)
def display_data(self, display_bits=True):
'''Print the protocol data to the terminal.'''
parties = self.network_manager.get_parties()
qubit_counts = self.calculate_qubit_counts()
print("Protocol iterations: {}".format(self.num_iterations))
print("Generated qubits: {}".format(qubit_counts[0]))
print("Transmitted qubits: {}".format(qubit_counts[1]))
print("Received qubits: {}".format(qubit_counts[2]))
min_key_length = math.inf
for uidA in parties:
partyA = parties[uidA]
secret_keys = partyA.secret_keys
if not secret_keys:
min_key_length = 0
break
secret_keys_by_uid = shared_fns.reorder_by_uid(secret_keys)
for uidB in secret_keys_by_uid:
key_length = len(list(secret_keys_by_uid[uidB]))
if key_length < min_key_length:
min_key_length = key_length
print("Secret key length: {}".format(min_key_length))
if not display_bits:
return
# Display the tx/rx bits & bases for each party.
for uidA in parties:
partyA = parties[uidA]
# Display the tx bits & bases, if they exist.
if partyA.tx_bits:
print("\nParty {} (tx)".format(partyA.name))
tx_bits = shared_fns.reorder_by_uid(partyA.tx_bits)
tx_bases = shared_fns.reorder_by_uid(partyA.tx_bases)
tx_bits_str = shared_fns.convert_dod_to_dos(tx_bits)
tx_bases_chars = shared_fns.represent_bases_by_chars(tx_bases)
tx_bases_str = shared_fns.convert_dod_to_dos(tx_bases_chars)
for uidB in tx_bits:
partyB = parties[uidB]
partyB_tx_bits_str = tx_bits_str[uidB]
partyB_tx_bases_str = tx_bases_str[uidB]
print(" {} -> {}: {}".format(partyA.name,
partyB.name,
partyB_tx_bits_str))
print(" {}".format(partyB_tx_bases_str))
# Display the rx bits & bases, if they exist.
if partyA.rx_bits:
print("\nParty {} (rx)".format(partyA.name))
rx_bits = shared_fns.reorder_by_uid(partyA.rx_bits)
rx_bases = shared_fns.reorder_by_uid(partyA.rx_bases)
rx_bits_str = shared_fns.convert_dod_to_dos(rx_bits)
rx_bases_chars = shared_fns.represent_bases_by_chars(rx_bases)
rx_bases_str = shared_fns.convert_dod_to_dos(rx_bases_chars)
for uidB in rx_bits:
partyB = parties[uidB]
partyB_rx_bits_str = rx_bits_str[uidB]
partyB_rx_bases_str = rx_bases_str[uidB]
print(" {} -> {}: {}".format(partyB.name,
partyA.name,
partyB_rx_bits_str))
print(" {}".format(partyB_rx_bases_str))
# Display the sifted keys.
print("\n")
for uidA in parties:
partyA = parties[uidA]
sifted_keys = partyA.sifted_keys
sifted_keys_by_uid = shared_fns.reorder_by_uid(sifted_keys)
sifted_key_strs = shared_fns.convert_dod_to_dos(sifted_keys_by_uid)
for uidB in sifted_keys_by_uid:
partyB = parties[uidB]
print("{} <-> {} key: {}".format(partyA.name,
partyB.name,
sifted_key_strs[uidB]))
# Display the check bits.
first_line = True
for uidA in parties:
partyA = parties[uidA]
check_bits = partyA.check_bits
check_bits_by_uid = shared_fns.reorder_by_uid(check_bits)
check_bits_strs = shared_fns.convert_dod_to_dos(check_bits_by_uid)
for uidB in check_bits_by_uid:
check_bits_exist = True
partyB = parties[uidB]
if first_line:
print()
first_line = False
print("{} <-> {} CBs: {}".format(partyA.name,
partyB.name,
check_bits_strs[uidB]))
# Display the secret keys.
first_line = True
for uidA in parties:
partyA = parties[uidA]
secret_keys = partyA.secret_keys
secret_keys_by_uid = shared_fns.reorder_by_uid(secret_keys)
secret_key_strs = shared_fns.convert_dod_to_dos(secret_keys_by_uid)
for uidB in secret_keys_by_uid:
partyB = parties[uidB]
if first_line:
print()
first_line = False
print("{} <-> {} key: {}".format(partyA.name,
partyB.name,
secret_key_strs[uidB]))
def make_manager(self, host, port):
dp_service = DebugPing()
nwm = NetworkManager(host=host, port=port)
nwm.add_service(dp_service)
return nwm, dp_service
class TestNetworkManager(TestCase):
nm = NetworkManager(0, {"compute_id": "vm", "name": "GNS3 VM (GNS3 VM)"})
def test_get_all_templates(self):
# expected= [
# {
# "adapter_type": "e1000",
# "adapters": 1,
# "bios_image": "",
# "boot_priority": "c",
# "builtin": False,
# "category": "guest",
# "cdrom_image": "",
# "compute_id": "vm",
# "console_auto_start": False,
# "console_type": "vnc",
# "cpu_throttling": 0,
# "cpus": 1,
# "custom_adapters": [],
# "default_name_format": "{name}-{0}",
# "first_port_name": "",
# "hda_disk_image": "linux-tinycore-linux-6.4-firefox-33.1.1-2.img",
# "hda_disk_interface": "ide",
# "hdb_disk_image": "",
# "hdb_disk_interface": "ide",
# "hdc_disk_image": "",
# "hdc_disk_interface": "ide",
# "hdd_disk_image": "",
# "hdd_disk_interface": "ide",
# "initrd": "",
# "kernel_command_line": "",
# "kernel_image": "",
# "legacy_networking": False,
# "linked_clone": True,
# "mac_address": "",
# "name": "Firefox 31.1.1~2",
# "on_close": "power_off",
# "options": "-vga std -usbdevice tablet",
# "platform": "i386",
# "port_name_format": "Ethernet{0}",
# "port_segment_size": 0,
# "process_priority": "normal",
# "qemu_path": "/usr/bin/qemu-system-i386",
# "ram": 256,
# "symbol": "firefox.svg",
# "template_id": "3279fa58-eef8-48ea-a6b9-a20bf1240d12",
# "template_type": "qemu",
# "usage": ""
# },
# {
# "adapter_type": "Intel PRO/1000 MT Desktop (82540EM)",
# "adapters": 1,
# "builtin": False,
# "category": "guest",
# "compute_id": "local",
# "console_auto_start": False,
# "console_type": "none",
# "custom_adapters": [],
# "default_name_format": "{name}-{0}",
# "first_port_name": "",
# "headless": False,
# "linked_clone": False,
# "name": "GNS3 VM",
# "on_close": "power_off",
# "port_name_format": "Ethernet{0}",
# "port_segment_size": 0,
# "ram": 2048,
# "symbol": ":/symbols/vbox_guest.svg",
# "template_id": "9893f914-515f-4baf-bdf8-e5dd3ac4e208",
# "template_type": "virtualbox",
# "usage": "",
# "use_any_adapter": False,
# "vmname": "GNS3 VM"
# },
# {
# "adapters": 1,
# "builtin": False,
# "category": "guest",
# "compute_id": "vm",
# "console_auto_start": False,
# "console_http_path": "/",
# "console_http_port": 80,
# "console_resolution": "1024x768",
# "console_type": "telnet",
# "custom_adapters": [],
# "default_name_format": "{name}-{0}",
# "environment": "",
# "extra_hosts": "",
# "extra_volumes": [],
# "image": "gns3/ubuntu:xenial",
# "name": "Ubuntu Docker Guest",
# "start_command": "",
# "symbol": "linux_guest.svg",
# "template_id": "d15fb3d1-0ba1-43d9-a725-e286bb6c1e56",
# "template_type": "docker",
# "usage": ""
# },
# {
# "adapter_type": "e1000",
# "adapters": 4,
# "bios_image": "",
# "boot_priority": "c",
# "builtin": False,
# "category": "router",
# "cdrom_image": "",
# "compute_id": "vm",
# "console_auto_start": False,
# "console_type": "telnet",
# "cpu_throttling": 0,
# "cpus": 1,
# "custom_adapters": [],
# "default_name_format": "{name}-{0}",
# "first_port_name": "",
# "hda_disk_image": "bird-tinycore64-1.5.0.img",
# "hda_disk_interface": "ide",
# "hdb_disk_image": "",
# "hdb_disk_interface": "ide",
# "hdc_disk_image": "",
# "hdc_disk_interface": "ide",
# "hdd_disk_image": "",
# "hdd_disk_interface": "ide",
# "initrd": "",
# "kernel_command_line": "",
# "kernel_image": "",
# "legacy_networking": False,
# "linked_clone": True,
# "mac_address": "",
# "name": "BIRD 1.5.0",
# "on_close": "power_off",
# "options": "",
# "platform": "i386",
# "port_name_format": "Ethernet{0}",
# "port_segment_size": 0,
# "process_priority": "normal",
# "qemu_path": "/usr/bin/qemu-system-x86_64",
# "ram": 128,
# "symbol": ":/symbols/classic/router.svg",
# "template_id": "6f38fbb5-ae7d-43b6-bd8f-8af1a06dd3cd",
# "template_type": "qemu",
# "usage": "Configure interfaces in /opt/bootlocal.sh, BIRD configuration is done in /usr/local/etc/bird"
# },
# {
# "adapters": 1,
# "builtin": False,
# "category": "guest",
# "compute_id": "vm",
# "console_auto_start": False,
# "console_http_path": "/",
# "console_http_port": 80,
# "console_resolution": "1024x768",
# "console_type": "telnet",
# "custom_adapters": [],
# "default_name_format": "{name}-{0}",
# "environment": "",
# "extra_hosts": "",
# "extra_volumes": [],
# "image": "alpine",
# "name": "Alpine Linux",
# "start_command": "",
# "symbol": "linux_guest.svg",
# "template_id": "0cf3b8a5-8a9c-4ba7-a900-e44ec8b13695",
# "template_type": "docker",
# "usage": ""
# },
# {
# "adapters": 1,
# "builtin": False,
# "category": "guest",
# "compute_id": "vm",
# "console_auto_start": False,
# "console_http_path": "/",
# "console_http_port": 80,
# "console_resolution": "1024x768",
# "console_type": "telnet",
# "custom_adapters": [],
# "default_name_format": "{name}-{0}",
# "environment": "",
# "extra_hosts": "",
# "extra_volumes": [],
# "image": "thomasbeckers/alpine-python3",
# "name": "thomasbeckers-alpine-python3",
# "start_command": "",
# "symbol": ":/symbols/docker_guest.svg",
# "template_id": "0fcf4286-b924-440a-88bd-f973871e4b9b",
# "template_type": "docker",
# "usage": ""
# },
# {
# "builtin": True,
# "category": "guest",
# "compute_id": None,
# "default_name_format": "Cloud{0}",
# "name": "Cloud",
# "symbol": ":/symbols/cloud.svg",
# "template_id": "39e257dc-8412-3174-b6b3-0ee3ed6a43e9",
# "template_type": "cloud"
# },
# {
# "builtin": True,
# "category": "guest",
# "compute_id": None,
# "default_name_format": "NAT{0}",
# "name": "NAT",
# "symbol": ":/symbols/cloud.svg",
# "template_id": "df8f4ea9-33b7-3e96-86a2-c39bc9bb649c",
# "template_type": "nat"
# },
# {
# "builtin": True,
# "category": "guest",
# "compute_id": None,
# "default_name_format": "PC{0}",
# "name": "VPCS",
# "properties": {
# "base_script_file": "vpcs_base_config.txt"
# },
# "symbol": ":/symbols/vpcs_guest.svg",
# "template_id": "19021f99-e36f-394d-b4a1-8aaa902ab9cc",
# "template_type": "vpcs"
# },
# {
# "builtin": True,
# "category": "switch",
# "compute_id": None,
# "console_type": "none",
# "default_name_format": "Switch{0}",
# "name": "Ethernet switch",
# "symbol": ":/symbols/ethernet_switch.svg",
# "template_id": "1966b864-93e7-32d5-965f-001384eec461",
# "template_type": "ethernet_switch"
# },
# {
# "builtin": True,
# "category": "switch",
# "compute_id": None,
# "default_name_format": "Hub{0}",
# "name": "Ethernet hub",
# "symbol": ":/symbols/hub.svg",
# "template_id": "b4503ea9-d6b6-3695-9fe4-1db3b39290b0",
# "template_type": "ethernet_hub"
# },
# {
# "builtin": True,
# "category": "switch",
# "compute_id": None,
# "default_name_format": "FRSW{0}",
# "name": "Frame Relay switch",
# "symbol": ":/symbols/frame_relay_switch.svg",
# "template_id": "dd0f6f3a-ba58-3249-81cb-a1dd88407a47",
# "template_type": "frame_relay_switch"
# },
# {
# "builtin": True,
# "category": "switch",
# "compute_id": None,
# "default_name_format": "ATMSW{0}",
# "name": "ATM switch",
# "symbol": ":/symbols/atm_switch.svg",
# "template_id": "aaa764e2-b383-300f-8a0e-3493bbfdb7d2",
# "template_type": "atm_switch"
# }
# ]
self.assertTrue(self.nm.get_all_templates() is not [])
def test_get_all_gns3vm(self):
# expected =[
# {
# "compute_id": "vmware",
# "name": "VMware Fusion (recommended)"
# },
# {
#
# "compute_id": "virtualbox",
# "name": "VirtualBox"
# },
# {
# "compute_id": "remote",
# "name": "Remote"
# }
# ]
self.assertTrue(self.nm.get_all_gns3vm() is not [])
def test_get_all_machines(self):
# expected = [
# {
# "compute_id": "local",
# "name": "MacBook-Pro-de-Maxime-9.local"
# },
# {
# "compute_id": "vm",
# "name": "GNS3 VM (GNS3 VM)"
# }
# ]
self.assertTrue(self.nm.get_all_machines() is not [])
def test_get_all_drawings(self):
# expected = [
# {
# "drawing_id": "63aa2322-577a-45b2-8e79-074da5184899",
# "locked": False,
# "project_id": "8cf37f7e-76a1-418c-9317-82e8586a1560",
# "rotation": 0,
# "svg": "<svg></svg>",
# "x": 0,
# "y": 0,
# "z": 2
# },
# {
# "drawing_id": "1f40e801-68e4-4ba0-87bd-458374ee8768",
# "locked": False,
# "project_id": "8cf37f7e-76a1-418c-9317-82e8586a1560",
# "rotation": 0,
# "svg": "<svg height=\"374\" width=\"528\"><rect fill=\"#ffffff\" fill-opacity=\"1.0\" height=\"374\" stroke=\"#000000\" stroke-width=\"2\" width=\"528\" /></svg>",
# "x": -465,
# "y": -360,
# "z": 1
# },
# {
# "drawing_id": "1a65ffb8-7283-466f-a8e1-8dc917eb8660",
# "locked": False,
# "project_id": "8cf37f7e-76a1-418c-9317-82e8586a1560",
# "rotation": 0,
# "svg": "<svg></svg>",
# "x": 0,
# "y": 0,
# "z": 2
# },
# {
# "drawing_id": "1d0bf1ff-5d16-406f-83ac-58a4603f5438",
# "locked": False,
# "project_id": "8cf37f7e-76a1-418c-9317-82e8586a1560",
# "rotation": 0,
# "svg": "<svg></svg>",
# "x": 0,
# "y": 0,
# "z": 2
# }
# ]
self.assertTrue(self.nm.get_all_drawings() is not [])
def test_get_all_links(self):
# expected = [
# {
# "capture_compute_id": None,
# "capture_file_name": None,
# "capture_file_path": None,
# "capturing": False,
# "filters": {},
# "link_id": "87321383-2e39-452f-b30a-dd71f46ca4c3",
# "link_type": "ethernet",
# "nodes": [],
# "project_id": "8cf37f7e-76a1-418c-9317-82e8586a1560",
# "suspend": False
# },
# {
# "capture_compute_id": None,
# "capture_file_name": None,
# "capture_file_path": None,
# "capturing": False,
# "filters": {},
# "link_id": "775aa0ed-911c-4e8e-9ff3-0e9bf55c37e1",
# "link_type": "ethernet",
# "nodes": [],
# "project_id": "8cf37f7e-76a1-418c-9317-82e8586a1560",
# "suspend": False
# },
# {
# "capture_compute_id": None,
# "capture_file_name": None,
# "capture_file_path": None,
# "capturing": False,
# "filters": {},
# "link_id": "2f9101dd-bdac-4ff2-bc90-e05ac07ced3b",
# "link_type": "ethernet",
# "nodes": [],
# "project_id": "8cf37f7e-76a1-418c-9317-82e8586a1560",
# "suspend": False
# },
# {
# "capture_compute_id": None,
# "capture_file_name": None,
# "capture_file_path": None,
# "capturing": False,
# "filters": {},
# "link_id": "b6bff2a2-1638-4384-a1e2-ffa9bf24ce72",
# "link_type": "ethernet",
# "nodes": [
# {
# "adapter_number": 0,
# "label": {
# "rotation": 0,
# "style": "font-family: TypeWriter;font-size: 10.0;font-weight: bold;fill: #000000;fill-opacity: 1.0;",
# "text": "e1",
# "x": 71,
# "y": -1
# },
# "node_id": "27515250-dbac-422e-9e11-1eefaf7ae76b",
# "port_number": 1
# },
# {
# "adapter_number": 0,
# "label": {
# "rotation": 0,
# "style": "font-family: TypeWriter;font-size: 10.0;font-weight: bold;fill: #000000;fill-opacity: 1.0;",
# "text": "e0",
# "x": -3,
# "y": 46
# },
# "node_id": "72e118c6-6799-4291-8fed-41d8c75fc522",
# "port_number": 0
# }
# ],
# "project_id": "8cf37f7e-76a1-418c-9317-82e8586a1560",
# "suspend": False
# },
# {
# "capture_compute_id": None,
# "capture_file_name": None,
# "capture_file_path": None,
# "capturing": False,
# "filters": {},
# "link_id": "14aa31f2-e44d-4b59-94f4-9215565d4b1b",
# "link_type": "ethernet",
# "nodes": [
# {
# "adapter_number": 0,
# "label": {
# "rotation": 0,
# "style": "font-family: TypeWriter;font-size: 10.0;font-weight: bold;fill: #000000;fill-opacity: 1.0;",
# "text": "e0",
# "x": 75,
# "y": 21
# },
# "node_id": "27515250-dbac-422e-9e11-1eefaf7ae76b",
# "port_number": 0
# },
# {
# "adapter_number": 0,
# "label": {
# "rotation": 0,
# "style": "font-family: TypeWriter;font-size: 10.0;font-weight: bold;fill: #000000;fill-opacity: 1.0;",
# "text": "e0",
# "x": -7,
# "y": 23
# },
# "node_id": "97e285e3-f752-4052-8a5a-6f2b4e2fb72d",
# "port_number": 0
# }
# ],
# "project_id": "8cf37f7e-76a1-418c-9317-82e8586a1560",
# "suspend": False
# },
# {
# "capture_compute_id": None,
# "capture_file_name": None,
# "capture_file_path": None,
# "capturing": False,
# "filters": {},
# "link_id": "8a95382f-653f-4777-9b41-520a610ddbaf",
# "link_type": "ethernet",
# "nodes": [
# {
# "adapter_number": 0,
# "label": {
# "rotation": 0,
# "style": "font-family: TypeWriter;font-size: 10.0;font-weight: bold;fill: #000000;fill-opacity: 1.0;",
# "text": "e2",
# "x": 28,
# "y": -23
# },
# "node_id": "27515250-dbac-422e-9e11-1eefaf7ae76b",
# "port_number": 2
# },
# {
# "adapter_number": 0,
# "label": {
# "rotation": 0,
# "style": "font-family: TypeWriter;font-size: 10.0;font-weight: bold;fill: #000000;fill-opacity: 1.0;",
# "text": "eth0",
# "x": 39,
# "y": 68
# },
# "node_id": "914d1c91-f727-4c95-a767-cb831b4fd264",
# "port_number": 0
# }
# ],
# "project_id": "8cf37f7e-76a1-418c-9317-82e8586a1560",
# "suspend": False
# },
# {
# "capture_compute_id": None,
# "capture_file_name": None,
# "capture_file_path": None,
# "capturing": False,
# "filters": {},
# "link_id": "7d88732d-4c7c-455b-9f1a-d9d7a5774149",
# "link_type": "ethernet",
# "nodes": [],
# "project_id": "8cf37f7e-76a1-418c-9317-82e8586a1560",
# "suspend": False
# },
# {
# "capture_compute_id": None,
# "capture_file_name": None,
# "capture_file_path": None,
# "capturing": False,
# "filters": {},
# "link_id": "67c8e9b7-a8e5-4bce-9291-8fe491cf3a39",
# "link_type": "ethernet",
# "nodes": [],
# "project_id": "8cf37f7e-76a1-418c-9317-82e8586a1560",
# "suspend": False
# }
# ]
self.assertTrue(self.nm.get_all_links() is not [])
def test_get_all_nodes(self):
# expected =[
# {
# "name": "AlpineLinux-1",
# "node_id": "914d1c91-f727-4c95-a767-cb831b4fd264"
# },
# {
# "name": "thomasbeckers-alpine-python3-1",
# "node_id": "fac28a86-2be5-4219-832c-a06837389ff7"
# },
# {
# "name": "PC1",
# "node_id": "72e118c6-6799-4291-8fed-41d8c75fc522"
# },
# {
# "name": "PC2",
# "node_id": "97e285e3-f752-4052-8a5a-6f2b4e2fb72d"
# },
# {
# "name": "Switch1",
# "node_id": "27515250-dbac-422e-9e11-1eefaf7ae76b"
# }
# ]
self.assertTrue(self.nm.get_all_nodes() is not [])
def test_get_all_project(self):
# expected =[
# {
# "auto_close": True,
# "auto_open": False,
# "auto_start": False,
# "drawing_grid_size": 25,
# "filename": "proto1.gns3",
# "grid_size": 75,
# "name": "proto1",
# "path": "/Users/maximebeugoms/GNS3/projects/proto1",
# "project_id": "8cf37f7e-76a1-418c-9317-82e8586a1560",
# "scene_height": 1000,
# "scene_width": 2000,
# "show_grid": False,
# "show_interface_labels": True,
# "show_layers": False,
# "snap_to_grid": True,
# "status": "opened",
# "supplier": None,
# "variables": None,
# "zoom": 35
# }
# ]
self.assertTrue(self.nm.get_all_project() is not [])
def test_get_all_snapshots(self):
# expected =[
# {
# "created_at": 1584656065,
# "name": "snapshot_testing_nm",
# "project_id": "8cf37f7e-76a1-418c-9317-82e8586a1560",
# "snapshot_id": "0ab187e5-2f4b-41d1-9b6d-8f7ecc57c988"
# }
# ]
self.assertTrue(self.nm.get_all_snapshots() is not [])
def test_post_template(self):
machine_template = {
"adapters": 1,
"builtin": False,
"category": "guest",
"compute_id": "vm",
"console_auto_start": False,
"console_http_path": "/",
"console_http_port": 80,
"console_resolution": "1024x768",
"console_type": "telnet",
"custom_adapters": [],
"default_name_format": "{name}-{0}",
"environment": "",
"extra_hosts": "",
"extra_volumes": [],
"image": "gns3/ubuntu:xenial",
"name": "Ubuntu Docker Guest",
"start_command": "",
"symbol": "linux_guest.svg",
"template_id": "d15fb3d1-0ba1-43d9-a725-e286bb6c1e56",
"template_type": "docker",
"usage": ""
}
# result_expected = {
# "command_line": None,
# "compute_id": "vm",
# "console": 5009,
# "console_auto_start": False,
# "console_host": "192.168.56.104",
# "console_type": "telnet",
# "custom_adapters": [],
# "first_port_name": None,
# "height": 59,
# "label": {
# "rotation": 0,
# "style": None,
# "text": "UbuntuDockerGuest-1",
# "x": None,
# "y": -40
# },
# "locked": False,
# "name": "UbuntuDockerGuest-1",
# "node_directory": "/opt/gns3/projects/8cf37f7e-76a1-418c-9317-82e8586a1560/project-files/docker/49cfbb85-a553-48cb-9193-c66c411339e8",
# "node_id": "49cfbb85-a553-48cb-9193-c66c411339e8",
# "node_type": "docker",
# "port_name_format": "Ethernet{0}",
# "port_segment_size": 0,
# "ports": [
# {
# "adapter_number": 0,
# "data_link_types": {
# "Ethernet": "DLT_EN10MB"
# },
# "link_type": "ethernet",
# "name": "eth0",
# "port_number": 0,
# "short_name": "eth0"
# }
# ],
# "project_id": "8cf37f7e-76a1-418c-9317-82e8586a1560",
# "properties": {
# "adapters": 1,
# "aux": 5010,
# "console_http_path": "/",
# "console_http_port": 80,
# "console_resolution": "1024x768",
# "container_id": "4aa379c99a5a8cc64dcd6155cf511b394019794c3852deec0977537cba63980c",
# "environment": None,
# "extra_hosts": None,
# "extra_volumes": [],
# "image": "gns3/ubuntu:xenial",
# "start_command": None,
# "usage": ""
# },
# "status": "stopped",
# "symbol": "linux_guest.svg",
# "template_id": "d15fb3d1-0ba1-43d9-a725-e286bb6c1e56",
# "width": 65,
# "x": 200,
# "y": 300,
# "z": 1
# }
self.assertTrue(
self.nm.post_template(machine_template, 300, 100) is not {})
def test_create_template_by_name(self):
self.assertEqual(
'd15fb3d1-0ba1-43d9-a725-e286bb6c1e56',
self.nm.create_template_by_name('Ubuntu Docker Guest', 300,
200)['template_id'])
def test_create_template_by_id(self):
self.assertEqual(
'd15fb3d1-0ba1-43d9-a725-e286bb6c1e56',
self.nm.create_template_by_id(
'd15fb3d1-0ba1-43d9-a725-e286bb6c1e56', 300,
300)['template_id'])
def test_get_one_machine_by_id(self):
expected_machine = {"compute_id": "vm", "name": "GNS3 VM (GNS3 VM)"}
self.assertEqual(
expected_machine,
self.nm.get_one_machine_by_id(expected_machine['compute_id']))
def test_get_one_machine_by_name(self):
expected_machine = {"compute_id": "vm", "name": "GNS3 VM (GNS3 VM)"}
self.assertEqual(
expected_machine,
self.nm.get_one_machine_by_name(expected_machine['name']))
def test_set_current_machine(self):
expected_machine = {"compute_id": "vm", "name": "GNS3 VM (GNS3 VM)"}
self.assertEqual(expected_machine, self.nm.selected_machine)
# def test_post_drawing(self):
# self.fail()
#
# def test_get_drawing(self):
# self.fail()
#
# def test_put_drawing(self):
# self.fail()
#
# def test_delete_drawing(self):
# self.fail()
#
def test_link_method(self):
# Test create link between 2 nodes
self.nm.create_template_by_name('Firefox', 200, 200)
self.nm.create_template_by_name('Alpine', 200, 300)
node1 = self.nm.get_one_node_by_name('Firefox')
node2 = self.nm.get_one_node_by_name('Alpine')
result = self.nm.link_nodes(node1['node_id'], node2['node_id'])
self.assertTrue(result is not {})
list_link = self.nm.get_all_links()
# Test to get one specific link
result = self.nm.get_one_link(list_link[0]['link_id'])
self.assertEqual(list_link[0], result)
# Infos about link
result = self.nm.get_link_node(node1['node_id'])
self.assertTrue(result is not [])
# Test the capture on a link
# Starting
# self.nm.start_node(node1['node_id'])
# self.nm.start_node(node2['node_id'])
# result = self.nm.start_capture_link(list_link[0]['link_id'])
# self.assertEqual(201, result.status_code)
# sleep(1)
# # Stopping
# result = self.nm.stop_capture_link(list_link[0]['link_id'])
# self.assertEqual(201,result.status_code)
# # Get the capturing file
# result = self.nm.get_pcap_link(list_link[0]['link_id'])
# self.assertEqual(200, result.status_code)
#
# self.nm.stop_node(node1['node_id'])
# self.nm.stop_node(node2['node_id'])
# Test to delete on specific link
result = self.nm.delete_link(list_link[0]['link_id'])
self.assertEqual(204, result.status_code)
self.nm.delete_node(node1['node_id'])
self.nm.delete_node(node2['node_id'])
def test_node_method(self):
list_nodes = self.nm.get_all_nodes()
# Update node
self.nm.put_node(list_nodes[0]['node_id'], {'x': 300, 'y': 300})
# Get specific node
result = self.nm.get_one_node_by_id(list_nodes[0]['node_id'])
result = self.nm.get_one_machine_by_name(list_nodes[0]['name'])
# Duplicate node
self.nm.duplicate_node(list_nodes[0]['node_id'], {'x': 400, 'y': 300})
# Starting node
self.nm.start_node(list_nodes[0]['node_id'])
# Stopping node
self.nm.stop_node(list_nodes[0]['node_id'])
# General manage
self.nm.start_all_nodes()
self.nm.stop_all_node()
self.nm.reload_all_node()
self.nm.stop_all_node()
# File manager
result = self.nm.add_file_to_node(list_nodes[0]['node_id'],
"/tmp/test.txt", "Hello word!")
self.assertEqual(201, result.status_code)
# Delete specific node
self.nm.delete_node(list_nodes[0]['node_id'])
def test_method_snapshot(self):
result = self.nm.post_snapshot({'name': 'snap_test'})
self.assertEqual(201, result.status_code)
result = result.json()
list_snaps = self.nm.get_all_snapshots()
snap_id = ''
for snap in list_snaps:
if snap['name'] == 'snap_test':
snap_id = snap['snapshot_id']
# print(list_snaps)
# res = self.nm.restore_snapshot(snap_id)
# self.assertEqual(201, res.status_code)
res = self.nm.delete_snapshot(snap_id)
self.assertEqual(204, res.status_code)
# coding=utf-8
from network_manager import NetworkManager
import sys
cmd = sys.argv[1:]
assert len(cmd) ==2 #verifier qu'on a bien seulement 2 arguments
ip, port = cmd
# Lancement du network manager
manager = NetworkManager(ip, int(port))
#Envoi du nom
groupname = "Agar.ia"
manager.send('NME', len(groupname), groupname)
#boucle principale
while True:
manager.update()
if manager.game_over == 1:
print("Bye bye.")
break
with fiona.open(os.path.join(DATA_RAW, 'crystal_palace_to_mursley.shp'),
'r') as source:
unprojected_line = next(iter(source))
unprojected_point = unprojected_line['geometry']['coordinates'][0]
for inter_site_distance in inter_site_distances:
print('--working on {}'.format(inter_site_distance))
transmitter, interfering_transmitters, cell_area, interfering_cell_areas = \
produce_sites_and_cell_areas(unprojected_point, inter_site_distance)
receivers = generate_receivers(cell_area, inter_site_distance,
SIMULATION_PARAMETERS)
MANAGER = NetworkManager(transmitter, interfering_transmitters,
receivers, cell_area, SIMULATION_PARAMETERS)
results = MANAGER.estimate_link_budget(
# frequency, bandwidth, generation, mast_height,
# environment,
MODULATION_AND_CODING_LUT,
SIMULATION_PARAMETERS)
csv_writer(results, os.path.join(DATA_PROCESSED, 'test_results'),
'test_capacity_data_{}.csv'.format(inter_site_distance))
geojson_receivers = convert_results_geojson(results)
write_shapefile(geojson_receivers,
'receivers_{}.shp'.format(inter_site_distance))
write_shapefile(transmitter,
from aiohttp import web
import socketio
import numpy as np
import base64
import imageio
from skimage.transform import resize
from network_manager import NetworkManager
# network
network_manager = NetworkManager(4000, 64, 0.0001)
# server
sio = socketio.AsyncServer(logger=True)
app = web.Application()
sio.attach(app)
async def index(_):
return web.Response(text="Server is running...")
app.router.add_get('/', index)
# socket events
@sio.on('connect')
def connect(sid, environ):
print("connected ", sid)
class MainWindow(QMainWindow, Ui_MainWindow):
add_name_signal = Signal(unicode)
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.setupUi(self)
# Create the name manager instance and move it to another thread.
# This will cause all the slots to be run in that other thread
# instead of our GUI thread.
self.name_manager = NameManager()
self.name_manager_thread = QThread()
self.name_manager.moveToThread(self.name_manager_thread)
self.name_manager_thread.start()
# Create our network manager
self.network_manager = NetworkManager()
# When the name manager emits it's full name list, we want to
# repopulate our list.
self.name_manager.names_signal.connect(self.populate_list)
# When the restore list button is clicked, let the name manager
# know we need all the names in long term storage
self.restore_list_button.clicked.connect(self.name_manager.get_all_names)
self.add_name_signal.connect(self.name_manager.store_name)
self.add_name_signal.connect(self.cache_name)
self.submit_button.clicked.connect(self.say_hello)
self.clear_list_button.clicked.connect(self.clear_list)
def clean_up(self):
"""
You can't rely on __del__ properly closing down all your threads. So use
a clean_up method that will be called manually.
:return:
"""
if hasattr(self, 'network_manager_thread'):
self.network_manager.api.end_connection()
self.network_manager.api.join()
self.network_manager_thread.quit()
self.name_manager_thread.quit()
def start_api(self, ip, port):
"""
Connect to an external API service which will send us names
:param ip: IP address of server
:param port: Port of service
:return:
"""
self.network_manager_thread = QThread()
self.network_manager.moveToThread(self.network_manager_thread)
self.network_manager.message_signal.connect(self.handle_message)
self.network_manager_thread.start()
self.network_manager.connect_signal.emit(ip, port)
@Slot()
def handle_message(self, message):
"""
Handle incoming names from the API. We simply want to follow the
established procedure to add a new name. So we just emit on that
signal.
:param message: String name
:return:
"""
self.add_name_signal.emit(message)
@Slot()
def say_hello(self):
self.add_name_signal.emit(self.name_text.text())
self.hello_label.setText(u"{} {}".format(GREETING, self.name_text.text()))
self.name_text.setText('')
@Slot()
def cache_name(self, name):
self.names_list.addItem(name)
@Slot()
def clear_list(self):
self.names_list.clear()
@Slot()
def populate_list(self, names):
"""
Clears and repopulates the list with the given list
:param names: List of names
:return:
"""
self.clear_list()
for name in names:
self.names_list.addItem(name)
def __init__(self):
print(colored.green("[*] Fetching active servers"))
self.net_manager = NetworkManager()
ip_list = self.net_manager.get_all_ip()
self.ips = self.net_manager.filter_active_server(ip_list)
print(colored.green("[+] Successfully extracted active servers."))
class TopologyManager:
"""
Class to manage the topology of any network we want on the gns3 server
"""
def __init__(self, networkManager=None, haveNat=False):
if networkManager is None:
self.nm = NetworkManager()
else:
self.nm = networkManager
self.dm = DockerManager(self.nm.selected_machine["compute_id"])
self.list_pcs = []
self.nat = None
self.flag_have_nat = haveNat
self.switch_lan = None
self.switch_services = None
self.switch_out = None
self.list_services = []
self.net_config_dhcp = '''# DHCP
auto eth0
iface eth0 inet dhcp
'''
def set_net_config_dhcp(self, new_config):
"""
This method set basic net config dhcp
:param new_config: str
"""
self.net_config_dhcp = new_config
pass
def create_n_node(self,
n: int,
template_name: str,
switch_selected: str = 'in_lan'):
"""
This method create n pcs (vpcs, vm, docker) link it to one switch (lan_switch)
:param n: number of pcs
:param template_name:The name of the template pc
:param switch_selected: the name of switch where we want create n vpcs
:return: add to list of pc the n new pcs
"""
self.check_switch_service()
if switch_selected == 'in_lan':
if self.switch_lan is None:
self.switch_lan = self.nm.create_template_by_name(
"Ethernet switch", self.switch_services['x'] + 300,
self.switch_services['y'])
self.nm.link_nodes(
self.switch_services['node_id'],
self.switch_lan['node_id'], [
0,
self.get_switch_port(self.switch_services),
self.get_switch_port(self.switch_lan)
])
# add n pc of template name
for i in range(n):
current_pc = self.nm.create_template_by_name(
template_name, self.switch_lan['x'] + 200,
self.switch_lan['y'] + (len(self.list_pcs)) * 100)
self.nm.add_file_to_node(current_pc["node_id"],
"/etc/network/interfaces",
self.net_config_dhcp)
self.nm.link_nodes(
self.switch_lan['node_id'], current_pc['node_id'],
[0, self.get_switch_port(self.switch_lan)], [0, 0])
self.list_pcs.append(current_pc)
elif switch_selected == 'in_service':
for i in range(n):
current_pc = self.nm.create_template_by_name(
template_name, self.switch_services['x'] +
(len(self.list_services)) * 100,
self.switch_services['y'] + 200)
self.nm.add_file_to_node(current_pc["node_id"],
"/etc/network/interfaces",
self.net_config_dhcp)
self.nm.link_nodes(
self.switch_services['node_id'], current_pc['node_id'],
[0, self.get_switch_port(self.switch_services)], [0, 0])
self.list_services.append(current_pc)
elif switch_selected == 'out':
if self.switch_out is None:
self.switch_out = self.nm.create_template_by_name(
"Ethernet switch", 130, 100)
net_config = '''# Static config
auto eth0
iface eth0 inet static
address 192.168.122.30
netmask 255.255.255.0
gateway 192.168.122.1
up echo nameserver 8.8.8.8 > /etc/resolv.conf
'''
for i in range(n):
current_pc = self.nm.create_template_by_name(
template_name, self.switch_out['x'],
self.switch_out['y'] + 200)
self.nm.add_file_to_node(current_pc["node_id"],
"/etc/network/interfaces", net_config)
self.nm.link_nodes(
self.switch_out['node_id'], current_pc['node_id'],
[0, self.get_switch_port(self.switch_out)], [0, 0])
self.list_pcs.append(current_pc)
else:
print(ColorOutput.ERROR_TAG + ": your position of switch flag (" +
switch_selected + ") isn't supported!")
exit(1)
pass
def get_switch_port(self, switch):
"""
Get the first empty port and add some if necessary ports to the specific switch
:param switch: the specific switch
:return: the number of the first empty port
"""
list_ports = []
for port in switch['properties']['ports_mapping']:
list_ports.append(port['port_number'])
last_port = list_ports[-1]
list_links = self.nm.get_link_node(switch['node_id'])
for link in list_links:
for node in link['nodes']:
if node['node_id'] == switch['node_id']:
list_ports.remove(node['port_number'])
if len(list_ports) == 0:
# must add port
for i in range(last_port + 1, 2 * last_port):
switch['properties']['ports_mapping'].append({
'name':
'Ethernet' + str(i),
'port_number':
i,
'type':
'access',
'vlan':
1
})
self.nm.put_node(switch['node_id'],
{'properties': switch['properties']})
return last_port + 1
else:
return list_ports[0]
def add_dns_adapter(self, node):
"""
Add one adapter to the specified node
:param node: the node where we want to add an adapter
:return:
"""
current_adapter = node['properties']['adapters']
node['properties']['adapters'] = current_adapter + 1
res = self.nm.put_node(
node['node_id'], {
'properties': {
'adapters': node['properties']['adapters'],
'start_command': ''
},
'node_type': node['node_type'],
'node_id': node['node_id'],
'compute_id': node['compute_id']
})
return res.json()
def clean(self):
"""
This method delete all nodes in the project
"""
list_nodes = self.nm.get_all_nodes()
for node in list_nodes:
self.nm.delete_node(node['node_id'])
pass
def create_DNS(self, personal_net_config_dns=None):
"""
This method create a dns
:param personal_net_config_dns: customize net config of dns
:return: the dns node
"""
self.check_switch_service()
if personal_net_config_dns is None:
personal_net_config_dns = """# Static config
auto eth0
iface eth0 inet static
address 192.168.122.10
netmask 255.255.255.0
gateway 192.168.122.1
up echo nameserver 8.8.8.8 > /etc/resolv.conf
auto eth1
iface eth1 inet static
address 10.0.0.1
netmask 255.255.255.0"""
dns = self.nm.create_template_by_name("thomasbeckers/dns", 250, 100)
dns = self.add_dns_adapter(dns)
self.nm.add_file_to_node(dns['node_id'], "/etc/network/interfaces",
personal_net_config_dns)
# linking to switch service
if self.flag_have_nat and self.nat is None:
self.nat = self.create_NAT()
self.nm.link_nodes(self.nat["node_id"], self.switch_out["node_id"],
[0, 0],
[0, self.get_switch_port(self.switch_out)])
if self.switch_out is None:
self.switch_out = self.nm.create_template_by_name(
"Ethernet switch", dns['x'] - 300, dns['y'])
self.nm.link_nodes(dns["node_id"], self.switch_out["node_id"], [0, 0],
[0, self.get_switch_port(self.switch_out)])
self.nm.link_nodes(dns["node_id"], self.switch_services["node_id"],
[1, 0],
[0, self.get_switch_port(self.switch_services)])
return dns
# dns must be started
def dns_config(self, dns):
"""
Add some config to the specific dns
:param dns: the specific dns
"""
self.nm.start_node(dns["node_id"])
time.sleep(2)
self.dm.exec_to_docker(
dns['properties']['container_id'],
"iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE")
self.dm.copy_to_docker("./config_files/dns/dnsmasq.conf",
dns["properties"]["container_id"], "/etc/")
self.dm.copy_to_docker("./config_files/dns/hosts",
dns["properties"]["container_id"], "/etc/")
self.dm.exec_to_docker(dns["properties"]["container_id"],
"service dnsmasq restart")
pass
def create_HTTP(self, personal_net_config_http=None):
"""
This method create an HTTP server
:param personal_net_config_http: custom net config http
:return: http node
"""
self.check_switch_service()
if personal_net_config_http is None:
personal_net_config_http = '''# Static config
auto eth0
iface eth0 inet static
address 10.0.0.14
netmask 255.255.255.0
gateway 10.0.0.1
up echo nameserver 8.8.8.8 > /etc/resolv.conf'''
http = self.nm.create_template_by_name(
"thomasbeckers/http",
self.switch_services['x'] + (len(self.list_services)) * 100,
self.switch_services['y'] + 200)
self.nm.add_file_to_node(http["node_id"], "/etc/network/interfaces",
personal_net_config_http)
# linking to switch services
self.nm.link_nodes(self.switch_services["node_id"], http['node_id'],
[0, self.get_switch_port(self.switch_services)],
[0, 0])
self.list_services.append(http)
return http
def get_http_nodes(self):
"""
:return: a list of all http server in the project
"""
list_http = []
for service in self.list_services:
if 'http' in service['name']:
list_http.append(service)
return list_http
def http_config(self, http):
"""
Add some config to a specific http server
:param http: the specific http server
"""
self.nm.start_node(http['node_id'])
self.dm.copy_to_docker("./config_files/http/database.php",
http["properties"]["container_id"],
'/var/www/html/')
pass
def create_FTP(self, personal_net_config_ftp=None):
"""
This method create a ftp server
:param personal_net_config_ftp: the custom net config ftp
:return: The ftp node
"""
self.check_switch_service()
if personal_net_config_ftp is None:
personal_net_config_ftp = '''# Static config
auto eth0
iface eth0 inet static
address 10.0.0.15
netmask 255.255.255.0
gateway 10.0.0.1
up echo nameserver 8.8.8.8 > /etc/resolv.conf'''
ftp = self.nm.create_template_by_name(
"thomasbeckers/ftp",
self.switch_services['x'] + (len(self.list_services)) * 100,
self.switch_services['y'] + 200)
self.nm.add_file_to_node(ftp['node_id'], "/etc/network/interfaces",
personal_net_config_ftp)
# linking to switch services
self.nm.link_nodes(self.switch_services['node_id'], ftp["node_id"],
[0, self.get_switch_port(self.switch_services)],
[0, 0])
self.list_services.append(ftp)
return ftp
def get_ftp_nodes(self):
"""
:return: a list of all ftp server in the project
"""
list_ftp = []
for service in self.list_services:
if 'ftp' in service['name']:
list_ftp.append(service)
return list_ftp
# node must be started
def ftp_config(self, ftp):
"""
Add some config to the ftp server
:param ftp: the specific ftp server
"""
self.nm.start_node(ftp["node_id"])
time.sleep(2)
self.dm.copy_to_docker("./config_files/ftp/vsftpd.conf",
ftp["properties"]["container_id"],
"/etc/vsftpd.conf")
self.dm.copy_to_docker("./python_scripts/write_file.py",
ftp["properties"]["container_id"],
"/srv/ftp/write_file.py")
self.dm.copy_to_docker("./config_files/ftp/files",
ftp["properties"]["container_id"], "/srv/ftp/")
self.dm.exec_to_docker(ftp["properties"]["container_id"],
"chown root:root /etc/vsftpd.conf")
self.dm.exec_to_docker(ftp["properties"]["container_id"],
"service vsftpd restart")
# time.sleep(2)
# self.nm.stop_node(ftp["node_id"])
pass
def set_net_config_dhcp_on(self, personal_net_config_dhcp):
"""
This method set the basic net config dhcp
"""
self.net_config_dhcp = personal_net_config_dhcp
pass
def create_NAT(self):
"""
This method create a NAT
"""
self.flag_have_nat = True
if self.switch_out is None:
self.switch_out = self.nm.create_template_by_name(
"Ethernet switch", 130, 100)
return self.nm.create_template_by_name("NAT", 0, 100)
def create_MAIL(self, personal_net_config_mail=None):
"""
This method create a mail server
:param personal_net_config_mail: custom net config mail server
:return: mail node
"""
self.check_switch_service()
if personal_net_config_mail is None:
personal_net_config_mail = '''# Static config
auto eth0
iface eth0 inet static
address 10.0.0.16
netmask 255.255.255.0
gateway 10.0.0.1
up echo nameserver 8.8.8.8 > /etc/resolv.conf'''
mail = self.nm.create_template_by_name(
"thomasbeckers/mail",
self.switch_services['x'] + (len(self.list_services)) * 100,
self.switch_services['y'] + 200)
self.nm.add_file_to_node(mail['node_id'], "/etc/network/interfaces",
personal_net_config_mail)
self.nm.link_nodes(self.switch_services['node_id'], mail["node_id"],
[0, self.get_switch_port(self.switch_services)],
[0, 0])
self.list_services.append(mail)
return mail
def check_switch_service(self):
"""
This method check if the switch service is already created otherwise create it
"""
if self.switch_services is None:
self.switch_services = self.nm.create_template_by_name(
"Ethernet switch", 450, 100)
# linking to switch_lan
if self.switch_lan is not None:
self.nm.link_nodes(
self.switch_services['node_id'],
self.switch_lan['node_id'],
[0, self.get_switch_port(self.switch_services)],
[0, self.get_switch_port(self.switch_lan)])
pass
def create_db(self, personal_net_config_db=None):
"""
This method create a server database
:param personal_net_config_db: custom personal net config for the db server
:return: db node
"""
self.check_switch_service()
if personal_net_config_db is None:
personal_net_config_db = '''# Static config
auto eth0
iface eth0 inet static
address 10.0.0.17
netmask 255.255.255.0
gateway 10.0.0.1
up echo nameserver 8.8.8.8 > /etc/resolv.conf'''
db = self.nm.create_template_by_name(
"thomasbeckers/db",
self.switch_services['x'] + (len(self.list_services)) * 100,
self.switch_services['y'] + 200)
self.nm.add_file_to_node(db["node_id"], "/etc/network/interfaces",
personal_net_config_db)
# linking to switch services
self.nm.link_nodes(self.switch_services["node_id"], db['node_id'],
[0, self.get_switch_port(self.switch_services)],
[0, 0])
self.list_services.append(db)
return db
def get_db_nodes(self):
"""
list all db servers in the project
:return:
"""
list_db = []
for service in self.list_services:
if 'db' in service['name']:
list_db.append(service)
return list_db
# db must be started
def db_config(self, db):
"""
Add some config to the specific db server
:param db: the specific db server
"""
self.nm.start_node(db['node_id'])
# wait mysql to start
time.sleep(5)
self.dm.copy_to_docker("./config_files/db/setup.sql",
db["properties"]["container_id"])
self.dm.exec_to_docker(db["properties"]["container_id"],
"/bin/sh -c 'mysql -u root < setup.sql'")
pass
def get_pc_nodes(self, name):
"""
This method allows to get a list of specific type of pcs.
:param name: The name of the specific pcs
:return: The list of the specific pcs
"""
list_template = []
for pc in self.list_pcs:
if name in pc['name']:
list_template.append(pc)
return list_template
class Seeker:
'''
Seeker class - consists of search and fetch operation from various servers in the subnet.
Main intention of this class is to traverse the network and perform various operations in a distributed manner.
Yet to add a way to traverse and index the whole network.
'''
def __init__(self):
print(colored.green("[*] Fetching active servers"))
self.net_manager = NetworkManager()
ip_list = self.net_manager.get_all_ip()
self.ips = self.net_manager.filter_active_server(ip_list)
print(colored.green("[+] Successfully extracted active servers."))
def process(self, operation, data):
'''
Receives argument from command line parser.
:param operation - defines the type of operation to be performed. Can be search or fetch yet.
:param data - defines resources required by the operation. handled by parser.
'''
if operation == 'search':
self._search_net(tag=data["tag"],
name=data["name"],
hash_val=data["hash"])
elif operation == 'fetch':
self._fetch_resource(data['url'], data['filename'])
elif operation == 'news':
self._get_broadcasts()
else:
print(colored.red("[!] Operation not found!!"))
def _search_net(self, tag=None, name=None, hash_val=None):
'''
Searches the subnet for files.
:param tag - type: str, a tag for searching among text files with various hashtags.
:param name - type: str, a name of file for searching, this parameter is least reliable
:param hash_val - type: str, a hash for a specific file for search, return quickest result
:return void
'''
# TODO:- find an efficient server search method, maybe an indexing server
# TODO:- Switch to Async await Multithreading
for ip in self.ips:
r = requests.get(f"http://{ip}:5000/search",
params=(("search_tag", tag),
("search_name", name), ("search_hash",
hash_val)))
print(ip, r.text)
def _get_broadcasts(self):
'''
Gets broadcasts from all servers in the subnet.
:return void
'''
for ip in self.ips:
r = requests.get(f"http://{ip}:5000/newsFlash")
print(colored.green(f"{ip} ==> {r.text}"))
def _fetch_resource(self, url, filename):
'''
Fetches file from a certain server using hash value.
:param url - type: str, url of the file to be downloaded.
Usually of the form:- http://127.0.0.1:5000/fetch/27e82jl58ue29ol91kn11h96xb
:param filename - type: str, file name to be used for downloaded file.
Filename can also be full path for file to be saved.
:return void
'''
r = requests.get(url)
if r.status_code == 200:
with open(filename, 'wb') as local_file:
for chunk in r.iter_content(chunk_size=128):
local_file.write(chunk)
# coding=utf-8
from network_manager import NetworkManager
import sys
cmd = sys.argv[1:]
assert len(cmd) == 2 #verifier qu'on a bien seulement 2 arguments
ip, port = cmd
# Lancement du network manager
manager = NetworkManager(ip, int(port))
#Envoi du nom
groupname = "Agar.ia"
manager.send('NME', len(groupname), groupname)
#boucle principale
while True:
manager.update()
if manager.game_over == 1:
print("Bye bye.")
break
import sys
sys.path.append("../protos")
sys.path.append("..")
import signal
import threading
import services
from network_manager import NetworkManager
# This file is meant to serve as a way to run a network manager indefinitely
# Boot up and wait for a keyboard interrupt
if __name__ == "__main__":
print('Starting Network Manager')
nwm = NetworkManager(host="172.18.0.1", port=13173)
nwm.add_service(services.DebugPing())
nwm.start()
def stop_server(signal, frame):
print('\nStopping Network Manager')
nwm.stop()
sys.exit(0)
signal.signal(signal.SIGINT, stop_server)
print("Ctr-c to stop")
forever = threading.Event()
forever.wait()
# put ping for the check co
for i in tqdm.tqdm(range(60)):
time.sleep(0.1)
network = None
if args.start:
time.sleep(1)
input("Press Enter after choose the recent project to continue...")
print("*"*10+" Launching the basic network topology "+"*"*10)
network = SimpleTopology()
if args.updater:
print("*"*10+"Network manager"+"*"*10)
net_manager = None
if network == None:
# Start a new topology
net_manager = NetworkManager()
else:
net_manager = network.nm
# Ready to modify the basic topology
if args.analyser:
print("analyser manager")
# os.system("python3 analyser_manager.py")
if args.Attacker:
print("attacker manager")
# os.system("python3 attacker_manager.py")
exit_key = input("Press 'q' to exit.\n").lower()
while exit_key != 'q':
exit_key = input("You enter a wrong value: "+str(exit_key)+". Please try with 'q' or 'Q'.").lower()
