def __init__(self, id: int, vlan_iface_name: str, vlan_iface_id: int, ip: str, ip_mask: int, config_ip: str, config_ip_mask: int, usr_name: str, usr_password: str, power_socket: int): RemoteSystem.__init__(self) self._id = id self._ip = ip self._ip_mask = ip_mask self._config_ip = config_ip self._config_ip_mask = config_ip_mask self._vlan_iface_id = vlan_iface_id self._vlan_iface_name = vlan_iface_name self._namespace_name = "nsp" + str(self._vlan_iface_id) self._power_socket = power_socket # Optional values self._mode = Mode.unknown self._model = "" self._usr_name = usr_name self._usr_password = usr_password self._mac = '00:00:00:00:00:00' self._ssid = '' self.interfaces = dict() self.cpu_processes = list() self.sockets = list() self._ram = None self._flashdriver = None self._firmware = Firmware.get_default_firmware()
def _verified_download(self, firmware: Firmware, hash_firmware: str, max_attempts: int) -> bool: """ Downloads the given Firmware and checks if the download was correct and if the hash is matching :param firmware: :param hash_firmware: :param max_attempts: max number of attemps to download a firmware :return: bool """ valid_download = False count = 0 while (not valid_download) & (count < max_attempts): valid_download = self._download_file(firmware.url, firmware.file, firmware.release_model) if valid_download: valid_download = firmware.check_hash(hash_firmware) count += 1 if count >= max_attempts: Logger().debug( "[-] The Firmware(" + firmware.name + ") couldn't be downloaded", 3) return False else: Logger().debug( "[+] The Firmware(" + firmware.name + ") was successfully downloaded", 3) return True
def import_firmwares(self, release_model: str): """ Imports the stored Firmwares, so the firmware_handler can use them. :param release_model: stable, beta, experimental """ path = FIRMWARE_PATH + '/' + release_model + '/' + self.UPDATE_TYPE + '/' logging.debug("%sImport Firmwares from '" + path + "'", LoggerSetup.get_log_deep(2)) count = 0 try: files = os.listdir(path) except Exception: logging.debug("%sNo Firmwares available for import at path '" + path + "'", LoggerSetup.get_log_deep(3)) return for firmware_name in files: try: freifunk_verein = firmware_name.split('-')[1] firmware_version = firmware_name.split('-')[2] file = path + firmware_name url = self.url + '/' + release_model + '/' + self.UPDATE_TYPE + '/' + firmware_name self.firmwares.append(Firmware(firmware_name, firmware_version, freifunk_verein, release_model, file, url)) count += 1 except Exception: logging.warning("%s[-] Couldn't import " + firmware_name, LoggerSetup.get_log_deep(3)) continue logging.debug("%s" + str(count) + " Firmwares imported", LoggerSetup.get_log_deep(3))
def _get_all_firmwares(self, release_model: str): """ Creats a list of Firmwares and a list of related Hashs. All Firmwares are given from the Manifest which is downloaded first. :param release_model: stable, beta, experimental :return: """ firmwares = [] hashs = [] non_parsed_firmwares = self._read_firmwares_from_manifest( release_model) for firmware in non_parsed_firmwares: firmware_name = "gluon" + firmware.split("gluon")[1].split("-sysupgrade")[0] + "-" + \ FirmwareHandler.UPDATE_TYPE + "." + firmware.split(".")[-1].replace("\n", "") hash_firmware = firmware.split(' ')[4] freifunk_verein = firmware_name.split('-')[1] firmware_version = firmware_name.split('-')[2] file = (self.FIRMWARE_PATH + '/' + release_model + '/' + FirmwareHandler.UPDATE_TYPE + '/' + firmware_name) url = self.url + '/' + release_model + '/' + FirmwareHandler.UPDATE_TYPE + '/' + firmware_name firmwares.append( Firmware(firmware_name, firmware_version, freifunk_verein, release_model, file, url)) hashs.append(hash_firmware) return [firmwares, hashs]
def _get_all_firmwares(self, release_model: str): """ Creats a list of Firmwares and a list of related hashs. All Firmwares are given from the Manifest which is downloaded first. :param release_model: Can be set to: 'stable', 'beta' or 'experimental'. Used in the url :return: Tuple of a list of Firmware-Obj and a list of hashs """ firmwares = [] hashs = [] non_parsed_firmwares = self._read_firmwares_from_manifest(release_model) for firmware in non_parsed_firmwares: if firmware.find("---\n") != -1: # skip the end of the file continue firmware_name = "gluon" + firmware.split("gluon")[1].split("-sysupgrade")[0] + "-" + \ FirmwareHandler.UPDATE_TYPE + "." + firmware.split(".")[-1].replace("\n", "") hash_firmware = firmware.split(' ')[4] freifunk_verein = firmware_name.split('-')[1] firmware_version = firmware_name.split('-')[2] file = (FIRMWARE_PATH + '/' + release_model + '/' + FirmwareHandler.UPDATE_TYPE + '/' + firmware_name) url = self.url + '/' + release_model + '/' + FirmwareHandler.UPDATE_TYPE + '/' + firmware_name firmwares.append(Firmware(firmware_name, firmware_version, freifunk_verein, release_model, file, url)) hashs.append(hash_firmware) return [firmwares, hashs]
def import_firmwares(self, release_model: str): """ Imports the stored Firmwares, so the firmware_handler can use them. :param release_model: stable, beta, experimental """ path = self.FIRMWARE_PATH + '/' + release_model + '/' + self.UPDATE_TYPE + '/' Logger().debug("Import Firmwares from '" + path + "'", 2) count = 0 try: files = os.listdir(path) except Exception as e: Logger().debug("No Firmwares available for download at path '" + path + "'", 3) return for firmware_name in files: try: freifunk_verein = firmware_name.split('-')[1] firmware_version = firmware_name.split('-')[2] file = path + firmware_name url = self.url + '/' + release_model + '/' + self.UPDATE_TYPE + '/' + firmware_name self.firmwares.append(Firmware(firmware_name, firmware_version, freifunk_verein, release_model, file, url)) count += 1 except Exception as e: Logger().warning("[-] Couldn't import " + firmware_name, 3) continue Logger().debug(str(count) + " Firmwares imported", 3)
def __init__(self, id: int, vlan_iface_name: str, vlan_iface_id: int, ip: str, ip_mask: int, config_ip: str, config_ip_mask: int, usr_name: str, usr_password: str, power_socket: int): ProxyObject.__init__(self) self._id = id self._ip = ip self._ip_mask = ip_mask self._config_ip = config_ip self._config_ip_mask = config_ip_mask self._vlan_iface_id = vlan_iface_id self._vlan_iface_name = vlan_iface_name self._namespace_name = "nsp" + str(self._vlan_iface_id) self._power_socket = power_socket # Optional values self._mode = Mode.unknown self._model = None self._usr_name = usr_name self._usr_password = usr_password self._mac = '00:00:00:00:00:00' self._wlan_mode = WlanMode.unknown self._ssid = '' self._firmware = Firmware.get_default_firmware()
def test_create_Firmware(self): firmware_name = "gluon-ffda-0.7.3-tp-link-tl-wr841n-nd-v9-sysupgrade.bin" url = "https://firmware.darmstadt.freifunk.net" firmware = Firmware(firmware_name, "0.7.3", "ffda", "stable", "/folder/folder/file", url) assert isinstance(firmware, Firmware) self.assertEqual(firmware_name, firmware.name) self.assertEqual("0.7.3", firmware.version) self.assertEqual("ffda", firmware.freifunk_verein) self.assertEqual("stable", firmware.release_model) self.assertEqual("/folder/folder/file", firmware.file) self.assertEqual(url, firmware.url)
def __init__(self, id: int, vlan_iface_name: str, vlan_iface_id: int, ip: str, ip_mask: int, config_ip: str, config_ip_mask: int, usr_name: str, usr_password: str, power_socket: int): """ :param id: The id of the Router :param vlan_iface_name: The name of the VLAN, which the Router is connected to :param vlan_iface_id: The id of the VLAN, which the RemoteSystem is connected to :param ip: The IP on which the RemoteSystem is listening in normal-mode :param ip_mask: Mask of the IP on which the RemoteSystem is listening in normal-mode :param config_ip: The IP on which the RemoteSystem is listening in configuration-mode :param config_ip_mask: Mask of the IP on which the RemoteSystem is listening in configuration-mode :param usr_name: The user-name that is used via SSH :param usr_password: The password that is used via SSH :param power_socket: The port on the power_socker where the Router is connected to. :return: """ RemoteSystem.__init__(self) self._id = id self._ip = ip self._ip_mask = ip_mask self._config_ip = config_ip self._config_ip_mask = config_ip_mask self._vlan_iface_id = vlan_iface_id self._vlan_iface_name = vlan_iface_name self._namespace_name = "nsp" + str(self._vlan_iface_id) self._usr_name = usr_name self._usr_password = usr_password self._power_socket = power_socket # Optional values self._mode = Mode.unknown self._model = "" self._mac = '00:00:00:00:00:00' self._node_name = "" self._public_key = "" self.network_interfaces = dict() self.cpu_processes = list() self.sockets = list() self._ram = None self._flashdriver = None self._firmware = Firmware.get_default_firmware() self.uci = dict() self.bat_originators = list()
def __init__( self, id: int, vlan_iface_name: str, vlan_iface_id: int, ip: str, ip_mask: int, config_ip: str, config_ip_mask: int, usr_name: str, usr_password: str, power_socket: int, ): ProxyObject.__init__(self) self._id = id self._ip = ip self._ip_mask = ip_mask self._config_ip = config_ip self._config_ip_mask = config_ip_mask self._vlan_iface_id = vlan_iface_id self._vlan_iface_name = vlan_iface_name self._namespace_name = "nsp" + str(self._vlan_iface_id) self._power_socket = power_socket # Optional values self._mode = Mode.unknown self._model = None self._usr_name = usr_name self._usr_password = usr_password self._mac = "00:00:00:00:00:00" self._wlan_mode = WlanMode.unknown self._ssid = "" self._firmware = Firmware.get_default_firmware()
def _verified_download(self, firmware: Firmware, hash_firmware: str, max_attempts: int) -> bool: """ Downloads the given Firmware and checks if the download was correct and if the hash is matching :param firmware: :param hash_firmware: :param max_attempts: max number of attemps to download a firmware :return: bool """ valid_download = False count = 0 while (not valid_download) & (count < max_attempts): valid_download = self._download_file(firmware.url, firmware.file, firmware.release_model) if valid_download: valid_download = firmware.check_hash(hash_firmware) count += 1 if count >= max_attempts: Logger().debug("[-] The Firmware(" + firmware.name + ") couldn't be downloaded", 3) return False else: Logger().debug("[+] The Firmware(" + firmware.name + ") was successfully downloaded", 3) return True
def test_setter(self): firmware_name = "gluon-ffda-0.7.3-tp-link-tl-wr841n-nd-v9-sysupgrade.bin" url = "https://firmware.darmstadt.freifunk.net" firmware = Firmware("", "", "", "", "", "") assert isinstance(firmware, Firmware) firmware.name = firmware_name firmware.version = "0.7.3" firmware.freifunk_verein = "ffda" firmware.release_model = "stable" firmware.file = "/folder/folder/file" firmware.url = url self.assertEqual(firmware_name, firmware.name) self.assertEqual("0.7.3", firmware.version) self.assertEqual("ffda", firmware.freifunk_verein) self.assertEqual("stable", firmware.release_model) self.assertEqual("/folder/folder/file", firmware.file) self.assertEqual(url, firmware.url)
def _verified_download(self, firmware: Firmware, hash_firmware: str, max_attempts: int) -> bool: """ Downloads the given Firmware and checks if the download was correct and if the hash is matching. :param firmware: Firmware-Obj :param hash_firmware: Expected hash :param max_attempts: Maximal number of attempts to download a Firmware :return: 'True' if the Firmware could be downloaded and the hash is correct """ valid_download = False count = 0 while (not valid_download) & (count < max_attempts): valid_download = self._download_file(firmware.url, firmware.file, firmware.release_model) if valid_download: valid_download = firmware.check_hash(hash_firmware) count += 1 if count >= max_attempts: logging.warning("%s[-] The Firmware(" + firmware.name + ") couldn't be downloaded", LoggerSetup.get_log_deep(3)) return False else: logging.info("%s[+] The Firmware(" + firmware.name + ") was successfully downloaded", LoggerSetup.get_log_deep(3)) return True