def _free_host(self, host): """ Stops ARP spoofing and unlimits host """ if host.spoofed: self.arp_spoofer.remove(host) self.limiter.unlimit(host) IO.ok('{}{}{} freed.'.format(IO.Fore.LIGHTYELLOW_EX, host.ip, IO.Style.RESET_ALL))
def interrupt_handler(self, ctrl_c=True): if ctrl_c: IO.spacer() IO.ok('cleaning up... stand by...') self.arp_spoofer.stop() for host in self.hosts: self._free_host(host)
def process_arguments(args): """ Processes the specified command-line arguments, adds them to a named tuple and returns. Executes actions specified in the command line, e.g. flush network settings """ if args.interface is None: interface = netutils.get_default_interface() if interface is None: IO.error('default interface could not be resolved. specify manually (-i).') return else: interface = args.interface if not netutils.exists_interface(interface): IO.error('interface {}{}{} does not exist.'.format(IO.Fore.LIGHTYELLOW_EX, interface, IO.Style.RESET_ALL)) return IO.ok('interface: {}{}{}'.format(IO.Fore.LIGHTYELLOW_EX, interface, IO.Style.RESET_ALL)) if args.gateway is None: gateway_ip = netutils.get_default_gateway() if gateway_ip is None: IO.error('default gateway address could not be resolved. specify manually (-g).') return else: gateway_ip = args.gateway IO.ok('gateway ip: {}{}{}'.format(IO.Fore.LIGHTYELLOW_EX, gateway_ip, IO.Style.RESET_ALL)) gateway_mac = netutils.get_mac_by_ip(interface, gateway_ip) if gateway_mac is None: IO.error('gateway mac address could not be resolved.') return IO.ok('gateway mac: {}{}{}'.format(IO.Fore.LIGHTYELLOW_EX, gateway_mac, IO.Style.RESET_ALL)) if args.netmask is None: netmask = netutils.get_default_netmask(interface) if netmask is None: IO.error('netmask could not be resolved. specify manually (-n).') return else: netmask = args.netmask IO.ok('netmask: {}{}{}'.format(IO.Fore.LIGHTYELLOW_EX, netmask, IO.Style.RESET_ALL)) if args.flush: netutils.flush_network_settings(interface) IO.spacer() IO.ok('flushed network settings') return InitialArguments(interface=interface, gateway_ip=gateway_ip, gateway_mac=gateway_mac, netmask=netmask)
def _block_handler(self, args): """ Handles 'block' command-line argument Blocks internet communication for host """ host = self._get_host_by_id(args.id) if host is not None: if not host.spoofed: self.arp_spoofer.add(host) self.limiter.block(host) IO.ok('{}{}{} blocked{}.'.format(IO.Fore.LIGHTYELLOW_EX, host.ip, IO.Fore.RED, IO.Style.RESET_ALL))
def _scan_handler(self, args): """ Handles 'scan' command-line argument (Re)scans for hosts on the network """ for host in self.hosts: self._free_host(host) IO.spacer() self.hosts = self.host_scanner.scan() IO.ok('{}{}{} hosts discovered.'.format(IO.Fore.LIGHTYELLOW_EX, len(self.hosts), IO.Style.RESET_ALL)) IO.spacer()
def _add_handler(self, args): """ Handles 'add' command-line argument Adds custom host to host list """ ip = args.ip if not netutils.validate_ip_address(ip): IO.error('invalid ip address.') return if args.mac: mac = args.mac if not netutils.validate_mac_address(mac): IO.error('invalid mac address.') return else: mac = netutils.get_mac_by_ip(self.interface, ip) if mac is None: IO.error( 'unable to resolve mac address. specify manually (--mac).') return name = None try: host_info = socket.gethostbyaddr(ip) name = None if host_info is None else host_info[0] except socket.herror: pass host = Host(ip, mac, name) with self.hosts_lock: if host in self.hosts: IO.error('host does already exist.') return self.hosts.append(host) IO.ok('host added.') IO.discord(""" ``` IP: {} MAC: {} NAME: {} Berhasil ditambahkan ``` """.format(host.ip, host.mac, host.name))
def scan(self): with ThreadPoolExecutor(max_workers=self.max_workers) as executor: hosts = [] iterator = tqdm( iterable=executor.map(self._sweep, self.iprange), total=len(self.iprange), ncols=45, bar_format='{percentage:3.0f}% |{bar}| {n_fmt}/{total_fmt}') try: for host in iterator: if host is not None: hosts.append(host) except KeyboardInterrupt: iterator.close() IO.ok('aborted. waiting for shutdown...') return hosts
def _block_handler(self, args): """ Handles 'block' command-line argument Blocks internet communication for host """ hosts = self._get_hosts_by_ids(args.id) direction = self._parse_direction_args(args) if hosts is not None and len(hosts) > 0: for host in hosts: if not host.spoofed: self.arp_spoofer.add(host) self.limiter.block(host, direction) IO.ok('{}{}{r} {} {}blocked{r}.'.format( IO.Fore.LIGHTYELLOW_EX, host.ip, Direction.pretty_direction(direction), IO.Fore.RED, r=IO.Style.RESET_ALL))
def _limit_handler(self, args): """ Handles 'limit' command-line argument Limits bandwith of host to specified rate """ hosts = self._get_hosts_by_ids(args.id) rate = args.rate if hosts is not None and len(hosts) > 0: for host in hosts: if not host.spoofed: self.arp_spoofer.add(host) if netutils.validate_netrate_string(rate): self.limiter.limit(host, rate) else: IO.error('limit rate is invalid.') return IO.ok('{}{}{} limited{} to {}.'.format(IO.Fore.LIGHTYELLOW_EX, host.ip, IO.Fore.LIGHTRED_EX, IO.Style.RESET_ALL, rate))
def _analyze_handler(self, args): hosts = self._get_hosts_by_ids(args.id) if hosts is None or len(hosts) == 0: IO.error('no hosts to be analyzed.') return duration = 30 # in s if args.duration: if not args.duration.isdigit(): IO.error('invalid duration.') return duration = int(args.duration) hosts_to_be_freed = set() host_values = {} for host in hosts: if not host.spoofed: hosts_to_be_freed.add(host) self.arp_spoofer.add(host) self.bandwidth_monitor.add(host) host_result = self.bandwidth_monitor.get(host) host_values[host] = {} host_values[host]['prev'] = (host_result.upload_total_size, host_result.download_total_size) IO.ok('analyzing traffic for {}s.'.format(duration)) time.sleep(duration) error_occurred = False for host in hosts: host_result = self.bandwidth_monitor.get(host) if host_result is None: # host reconnected during analysis IO.error('host reconnected during analysis.') error_occurred = True else: host_values[host]['current'] = ( host_result.upload_total_size, host_result.download_total_size) IO.ok('cleaning up...') for host in hosts_to_be_freed: self._free_host(host) if error_occurred: return upload_chart = BarChart(max_bar_length=29) download_chart = BarChart(max_bar_length=29) for host in hosts: upload_value = host_values[host]['current'][0] - host_values[host][ 'prev'][0] download_value = host_values[host]['current'][1] - host_values[ host]['prev'][1] prefix = '{}{}{} ({}, {})'.format(IO.Fore.LIGHTYELLOW_EX, self._get_host_id(host), IO.Style.RESET_ALL, host.ip, host.name) upload_chart.add_value(upload_value.value, prefix, upload_value) download_chart.add_value(download_value.value, prefix, download_value) upload_table = SingleTable([[upload_chart.get()]], 'Upload') download_table = SingleTable([[download_chart.get()]], 'Download') upload_table.inner_heading_row_border = False download_table.inner_heading_row_border = False IO.spacer() IO.print(upload_table.table) IO.print(download_table.table) IO.spacer()