#!/usr/bin/env python
# efknockr (internet relay chat drive-by tool) - developed by acidvegas in python (https://git.acid.vegas/efknockr)

'''
WARNING: This script is riddled with purposely made mistakes to prevent abuse LOL.
'''

import asyncio
import ipaddress
import os
import random
import re
import ssl
import sys
import time
import urllib.request

class settings:
	chan_first           = False          # Finish knocking channels before sending private messages
	confuse              = True           # Use unicode confusables in messages to avoid spamfilters
	daemon               = False          # Run in daemon mode (24/7 throttled knocking)
	errors               = True           # Show errors in console
	errors_conn          = False          # Show connection errors in console
	exploits             = False          # Use a exploit payloads
	mass_hl              = True           # Hilite all the users in a channel before parting
	part_msg             = 'Smell ya l8r' # Send a custom part message when leaving channels
	proxies              = False          # Connect with proxies
	proxies_only         = False          # Only connect with proxies
	proxies_scan         = False          # Scan for new proxies
	proxies_local        = False          # Use proxies from proxies.txt
	register             = True           # Register with NickServ before joining channels
	register_chan        = '#EFKnockr'    # Set to None to disable channel registrations
	register_chan_topic = 'EFK'           # Topic to set for the registered channel

class throttle:
	channels  = 3   if not settings.daemon else 2   # Maximum number of channels to knock at once
	connect   = 15  if not settings.daemon else 60  # Delay between each connection attempt on a diffferent port
	delay     = 300 if not settings.daemon else 600 # Delay before registering nick (if enabled) & sending /LIST
	jdelay    = 3   if not settings.daemon else 10  # Delay before messaging a channel
	join      = 10  if not settings.daemon else 30  # Delay between channel JOINs
	message   = 1.5 if not settings.daemon else 3   # Delay between each message sent
	nick      = 300 if not settings.daemon else 600 # Delay between every random NICK change
	nicks     = 5   if not settings.daemon else 15  # Delay between each nick private messaged
	private   = 5   if not settings.daemon else 15  # Delay between private messages
	pthreads  = 500 if not settings.daemon else 300 # Maximum number of threads for proxy checking
	ptimeout  = 15  if not settings.daemon else 30  # Timeout for all sockets
	seconds   = 300 if not settings.daemon else 600 # Maximum seconds to wait when throttled for JOIN or PM
	users     = 10  if not settings.daemon else 5   # Minimum number of users in a channel to knock
	threads   = 500 if not settings.daemon else 50  # Maximum number of threads running
	timeout   = 30  if not settings.daemon else 60  # Timeout for all sockets
	ztimeout  = 200 if not settings.daemon else 300 # Timeout for zero data from server ;) ;) ;)

messages = (
	'This message has been brought to you by EFknockr!',
	'WHAT IS UP PORT 6667!?',
	['multi','lined','message','example'],
	['cant','    stop','        me','cause','    im a','        pumper'],
	'b i g   a c i d v e g a s   h a s   u'
)

class bad:
	donotscan = (
		'irc.terahertz.net',     '165.254.255.25',        '2001:728:1808::25',
		'irc.dronebl.org',       'irc.alphachat.net',
		'5.9.164.48',            '45.32.74.177',          '104.238.146.46',               '149.248.55.130',
		'2001:19f0:6001:1dc::1', '2001:19f0:b001:ce3::1', '2a01:4f8:160:2501:48:164:9:5', '2001:19f0:6401:17c::1'
	)
	chan = {
		'403' : 'ERR_NOSUCHCHANNEL',    '405' : 'ERR_TOOMANYCHANNELS',
		'435' : 'ERR_BANONCHAN',        '442' : 'ERR_NOTONCHANNEL',
		'448' : 'ERR_FORBIDDENCHANNEL', '470' : 'ERR_LINKCHANNEL',
		'471' : 'ERR_CHANNELISFULL',    '473' : 'ERR_INVITEONLYCHAN',
		'474' : 'ERR_BANNEDFROMCHAN',   '475' : 'ERR_BADCHANNELKEY',
		'476' : 'ERR_BADCHANMASK',      '477' : 'ERR_NEEDREGGEDNICK',
		'479' : 'ERR_BADCHANNAME',      '480' : 'ERR_THROTTLE',
		'485' : 'ERR_CHANBANREASON',    '488' : 'ERR_NOSSL',
		'489' : 'ERR_SECUREONLYCHAN',   '519' : 'ERR_TOOMANYUSERS',
		'520' : 'ERR_OPERONLY',         '926' : 'ERR_BADCHANNEL'
	}
	error = {
		'install identd'                 : 'Identd required',
		'trying to reconnect too fast'   : 'Throttled',
		'trying to (re)connect too fast' : 'Throttled',
		'reconnecting too fast'          : 'Throttled',
		'access denied'                  : 'Access denied',
		'not authorized to'              : 'Not authorized',
		'not authorised to'              : 'Not authorized',
		'password mismatch'              : 'Password mismatch',
		'dronebl'                        : 'DroneBL',
		'dnsbl'                          : 'DNSBL',
		'g:lined'                        : 'G:Lined',
		'z:lined'                        : 'Z:Lined',
		'timeout'                        : 'Timeout',
		'closing link'                   : 'Banned',
		'banned'                         : 'Banned',
		'client exited'                  : 'QUIT',
		'quit'                           : 'QUIT'
	}

# Globals
all_proxies  = list()
good_proxies = list()

def confuse(data):
	if settings.confuse:
		chars = ''
		for char in data:
			if random.choice((True,False,False)):
				if char == ' ':
					chars += '\u00A0'
				elif char.lower() in ('abcdefghijklmnopqrstvwyz'):
					chars += char + random.choice(('\u200B','\u2060','\x0f','\x03\x0f'))
				else:
					chars += char
			else:
				chars += char
		return ''.join(chars)
	else:
		return data

def debug(data):
	print('{0} \033[1;30m|\033[0m [\033[35m~\033[0m] {1}'.format(time.strftime('%I:%M:%S'), data))

def error(data, reason=None):
	if settings.errors:
		print('{0} \033[1;30m|\033[0m [\033[31m!\033[0m] {1} \033[1;30m({2})\033[0m'.format(time.strftime('%I:%M:%S'), data, str(reason))) if reason else print('{0} \033[1;30m|\033[0m [\033[31m!\033[0m] {1}'.format(time.strftime('%I:%M:%S'), data))

def get_proxies():
	urls = (
		'https://find-your-own-proxies.com/socks5.txt',
		'https://find-your-own-proxies.com/socks5.txt',
		'https://find-your-own-proxies.com/socks5.txt'
	)
	proxies = list()
	for url in urls:
		try:
			req = urllib.request.Request(url)
			req.add_header('User-Agent', 'Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)')
			source  = urllib.request.urlopen(req, timeout=10).read().decode()
			proxies+= list(set([proxy for proxy in re.findall('[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+:[0-9]+', source, re.MULTILINE) if proxy not in proxies]))
		except Exception as ex:
			error('failed to grab new proxies!', ex)
	return proxies if proxies else False

async def check_proxy(semaphore, proxy):
	async with semaphore:
		ip, port = proxy.split(':')
		options = {
			'proxy'      : aiosocks.Socks5Addr(proxy.split(':')[0], int(proxy.split(':')[1])),
			'proxy_auth' : None,
			'dst'        : ('www.google.com',80),
			'limit'      : 1024,
			'ssl'        : None,
			'family'     : 2
		}
		try:
			await asyncio.wait_for(aiosocks.open_connection(**options), throttle.ptimeout)
		except:
			pass
		else:
			debug('\033[1;32mGOOD\033[0m \033[1;30m|\033[0m ' + proxy)
			if ip not in all_proxies:
				all_proxies.append(ip)
				good_proxies.append(proxy)

def rndnick():
	prefix = random.choice(['st','sn','cr','pl','pr','fr','fl','qu','br','gr','sh','sk','tr','kl','wr','bl']+list('bcdfgklmnprstvwz'))
	midfix = random.choice(('aeiou'))+random.choice(('aeiou'))+random.choice(('bcdfgklmnprstvwz'))
	suffix = random.choice(['ed','est','er','le','ly','y','ies','iest','ian','ion','est','ing','led','inger']+list('abcdfgklmnprstvwz'))
	return prefix+midfix+suffix

def ssl_ctx():
	ctx = ssl.create_default_context()
	ctx.check_hostname = False
	ctx.verify_mode = ssl.CERT_NONE
	return ctx

class probe:
	def __init__(self, semaphore, server, proxy=None):
		self.semaphore = semaphore
		self.server    = server
		self.proxy     = proxy
		self.display   = server.ljust(18)+' \033[1;30m|\033[0m unknown network           \033[1;30m|\033[0m '
		self.nickname  = rndnick()
		self.channels  = {'all':list(), 'current':list(), 'users':dict(), 'bad':list()}
		self.nicks     = {'all':list(), 'chan':dict(),    'check':list(), 'bad':list()}
		self.loops     = {'init':None, 'chan':None, 'nick':None, 'pm':None}
		self.jthrottle = throttle.join
		self.nthrottle = throttle.private
		self.reader    = None
		self.write     = None

	async def sendmsg(self, target, msg):
		await self.raw(f'PRIVMSG {target} :{msg}')

	async def run(self):
		async with self.semaphore:
			try:
				await self.connect() # 6697
			except Exception as ex:
				if settings.errors_conn:
					error(self.display + '\033[1;31mdisconnected\033[0m - failed to connect using SSL/TLS!', ex)
				await asyncio.sleep(throttle.connect)
				try:
					await self.connect(True) # 6667
				except Exception as ex:
					if settings.errors_conn:
						error(self.display + '\033[1;31mdisconnected\033[0m - failed to connect!', ex)

	async def raw(self, data):
		self.writer.write(data[:510].encode('utf-8') + b'\r\n')
		await self.writer.drain()

	async def connect(self, fallback=False):
		if self.proxy:
			auth = self.proxy.split('@')[0].split(':') if '@' in self.proxy else None
			proxy_ip, proxy_port = self.proxy.split('@')[1].split(':') if '@' in self.proxy else self.proxy.split(':')
			options = {
				'proxy'      : aiosocks.Socks5Addr(proxy_ip, proxy_port),
				'proxy_auth' : aiosocks.Socks5Auth(*auth) if auth else None,
				'dst'        : (self.server,6667) if fallback else (self.server,6697),
				'limit'      : 1024,
				'ssl'        : None if fallback else ssl_ctx(),
				'family'     : 2
			}
			self.reader, self.writer = await asyncio.wait_for(aiosocks.open_connection(**options), throttle.timeout)
		else:
			options = {
				'host'   : self.server,
				'port'   : 6667 if fallback else 6697,
				'limit'  : 1024,
				'ssl'    : None if fallback else ssl_ctx(),
				'family' : 2
			}
			self.reader, self.writer = await asyncio.wait_for(asyncio.open_connection(**options), throttle.timeout)
		del options
		await self.raw('USER {0} 0 * :{1}'.format(rndnick(), rndnick()))
		await self.raw('NICK ' + self.nickname)
		await self.listen()
		for item in self.loops:
			if self.loops[item]:
				self.loops[item].cancel()
		debug(self.display + 'finished knocking')

	async def loop_initial(self):
		try:
			await asyncio.sleep(throttle.delay)
			mail = rndnick() + '@' + random.choice(('gmail.com','hotmail.com','yahoo.com','outlook.com','protonmail.com','mail.com',rndnick()+random.choice(('com','org','net'))))
			cmds = [f'PRIVMSG NickServ :REGISTER {rndnick()} {mail}', 'LIST']
			for command in cmds:
				try:
					await self.raw(command)
				except:
					break
				else:
					await asyncio.sleep(3)
			if not self.channels['all']:
				error(self.display + '\033[31merror\033[0m - no channels found')
				await self.raw('QUIT')
		except asyncio.CancelledError:
			pass
		except Exception as ex:
			error(self.display + '\033[31merror\033[0m - loop_initial', ex)

	async def loop_channels(self):
		try:
			while self.channels['all']:
				while len(self.channels['current']) >= throttle.channels:
					await asyncio.sleep(1)
				await asyncio.sleep(self.jthrottle)
				chan = random.choice(self.channels['all'])
				self.channels['all'].remove(chan)
				try:
					await self.raw('JOIN ' + chan)
				except:
					break
			if settings.chan_first:
				self.loops['pm'] = asyncio.create_task(self.loop_private())
			while self.nicks['check']:
				await asyncio.sleep(1)
			self.loops['nick'].cancel()
			self.loops['pm'].cancel()
			await self.raw('QUIT')
		except asyncio.CancelledError:
			pass
		except Exception as ex:
			error(self.display + '\033[31merror\033[0m - loop_channels', ex)

	async def loop_nick(self):
		try:
			while True:
				await asyncio.sleep(throttle.nick)
				self.nickname = rndnick()
				await self.raw('NICK ' + self.nickname)
		except asyncio.CancelledError:
			pass
		except Exception as ex:
			error(self.display + '\033[31merror\033[0m - loop_nick', ex)

	async def loop_private(self):
		try:
			while True:
				if self.nicks['check']:
					nick = random.choice(self.nicks['check'])
					self.nicks['check'].remove(nick)
					try:
						msg = random.choice(messages)
						if type(msg) == list:
							for i in msg:
								if nick in self.nicks['bad']:
									self.nicks['bad'].remove(nick)
									break
								else:
									await self.sendmsg(nick, confuse(i))
									await asyncio.sleep(throttle.message)
						else:
							await self.sendmsg(nick, confuse(msg))
					except:
						break
					else:
						del nick
						await asyncio.sleep(throttle.nicks)
				else:
					await asyncio.sleep(1)
		except asyncio.CancelledError:
			pass
		except Exception as ex:
			error(self.display + '\033[31merror\033[0m - loop_private', ex)

	async def listen(self):
		while True:
			try:
				if self.reader.at_eof():
					break
				data  = await asyncio.wait_for(self.reader.readuntil(b'\r\n'), throttle.ztimeout)
				line  = data.decode('utf-8').strip()
				args  = line.split()
				event = args[1].upper()
				if event in bad.chan and len(args) >= 4:
					chan = args[3]
					if chan in self.channels['users']:
						del self.channels['users'][chan]
					if chan in self.nicks['chan']:
						del self.nicks['chan'][chan]
					error(f'{self.display}\033[31merror\033[0m - {chan}', bad.chan[event])
				elif line.startswith('ERROR :'):
					check = [check for check in bad.error if check in line.lower()]
					if check:
						raise Exception(bad.error[check[0]])
				elif args[0] == 'PING':
					await self.raw('PONG ' + args[1][1:])
				elif event == '001': #RPL_WELCOME
					host = args[0][1:]
					if len(host) > 25:
						self.display = f'{self.server.ljust(18)} \033[1;30m|\033[0m {host[:22]}... \033[1;30m|\033[0m '
					else:
						self.display = f'{self.server.ljust(18)} \033[1;30m|\033[0m {host.ljust(25)} \033[1;30m|\033[0m '
					debug(self.display + f'\033[1;32mconnected\033[0m')
					self.loops['init'] = asyncio.create_task(self.loop_initial())
				elif event == '315' and len(args) >= 3: #RPL_ENDOFWHO
					chan = args[3]
					await asyncio.sleep(throttle.jdelay)
					msg = random.choice(messages)
					if type(msg) == list:
						for i in msg:
							if chan in self.channels['bad']:
								self.channels['bad'].remove(chan)
								break
							else:
								await self.sendmsg(chan, confuse(i))
								await asyncio.sleep(throttle.message)
					else:
						await self.sendmsg(chan, confuse(msg))
					if settings.exploits:
						pass # TODO: add exploits
					if settings.mass_hl:
						self.nicks['chan'][chan] = ' '.join(self.nicks['chan'][chan])
						if len(self.nicks['chan'][chan]) <= 400:
							await self.sendmsg(chan, self.nicks['chan'][chan])
						else:
							while len(self.nicks['chan'][chan]) > 400:
								if chan in self.channels['bad']:
									self.channels['bad'].remove(chan)
									break
								else:
									segment = self.nicks['chan'][chan][:400]
									segment = segment[:-len(segment.split()[len(segment.split())-1])]
									await self.sendmsg(chan, segment)
									self.nicks['chan'][chan] = self.nicks['chan'][chan][len(segment):]
									await asyncio.sleep(throttle.message)
					await self.raw(f'PART {chan} :{settings.part_msg}')
					self.channels['current'].remove(chan)
					del self.nicks['chan'][chan]
					if chan in self.channels['bad']:
						self.channels['bad'].remove(chan)
				elif event == '322' and len(args) >= 4: # RPL_LIST
					chan  = args[3]
					users = args[4]
					if len(self.channels['all']) >= 20000:
						error(self.display + 'LIST tarpit detected!') # Make it     wuddup
						error(self.display + 'LIST tarpit detected!') # stand out           pi55
						error(self.display + 'LIST tarpit detected!') # more                       n3t
						self.snapshot['TARPIT'] = True
						await self.raw('QUIT')
					if users != '0': # no need to JOIN empty channels...
						if chan not in ('#dronebl','#help','#opers'): # lets avoid the channels that are going to get use banned/blacklisted
							self.channels['all'].append(chan)
							self.channels['users'][chan] = users
				elif event == '323': # RPL_LISTEND
					if self.channels['all']:
						debug(self.display + '\033[36mLIST\033[0m found \033[93m{0}\033[0m channel(s)'.format(str(len(self.channels['all']))))
						self.loops['chan'] = asyncio.create_task(self.loop_channels())
						self.loops['nick'] = asyncio.create_task(self.loop_nick())
						if not settings.chan_first:
							self.loops['pm']   = asyncio.create_task(self.loop_private())
				elif event == '352' and len(args) >= 8: # RPL_WHORPL
					chan = args[3]
					nick = args[7]
					self.nicks['chan'][chan].append(nick)
					if nick not in self.nicks['all']+[self.nickname,]:
						self.nicks['all'].append(nick)
						self.nicks['check'].append(nick)
				elif event == '366' and len(args) >= 4: # RPL_ENDOFNAMES
					chan = args[3]
					self.nicks['chan'][chan] = list()
					self.channels['current'].append(chan)
					if chan in self.channels['users']:
						debug('{0}\033[32mJOIN\033[0m {1} \033[1;30m(found \033[93m{2}\033[0m users)\033[0m'.format(self.display, chan, self.channels['users'][chan]))
						del self.channels['users'][chan]
					await self.raw('WHO ' + chan)
					# MADE YOU LOOK LOL GET FUCKED XD
				elif event == '404' and len(args) >= 5: # ERR_CANNOTSENDTOCHAN
					chan = args[3]
					msg  = ' '.join(args[4:])[1:]
					error(self.display + '\033[31merror\033[0m - failed to knock ' + chan, msg)
					if chan not in self.channels['bad']:
						self.channels['bad'].append(chan)
				elif event == '421' and len(args) >= 3: # ERR_UNKNOWNCOMMAND
					msg = ' '.join(args[2:])
					if 'You must be connected for' in msg:
						error(self.display + '\033[31merror\033[0m - delay found', msg)
				elif event == '433': # ERR_NICKINUSE
					self.nickname = rndnick()
					await self.raw('NICK ' + self.nickname)
				elif event == '439' and len(args) >= 11: # ERR_TARGETTOOFAST
					target = args[3]
					msg    = ' '.join(args[4:])[1:]
					seconds = args[10]
					if target[:1] in ('#','&'):
						self.channels['all'].append(target)
						if seconds.isdigit():
							self.jthrottle = throttle.seconds if int(seconds) > throttle.seconds else int(seconds)
					else:
						self.nicks['check'].append(target)
						if seconds.isdigit():
							self.nthrottle = throttle.seconds if int(seconds) > throttle.seconds else int(seconds)
					error(self.display + '\033[31merror\033[0m - delay found for ' + target, msg)
				elif event == '465': # ERR_YOUREBANNEDCREEP
					check = [check for check in bad.error if check in line.lower()]
					if check:
						raise Exception(bad.error[check[0]])
				elif event == '464': # ERR_PASSWDMISMATCH
					raise Exception('Network has a password')
				elif event == '487': # ERR_MSGSERVICES
					if '"/msg NickServ" is no longer supported' in line: # TODO: need to do this for ChanServ aswell
						await self.raw('/NickServ REGISTER {0} {1}'.format(rndnick(), f'{rndnick()}@{rndnick()}.com'))
				elif args[1] in ('716','717'): # RPL_TARGUMODEG / RPL_TARGNOTIFY
					nick = args[2] #TODO: verify this is the correct arguement
					if nick not in self.nicks['bad']:
						self.nicks['bad'].append(nick)
				elif event == 'KICK' and len(args) >= 4:
					chan   = args[2]
					kicked = args[3]
					if kicked == self.nickname:
						if chan in self.channels['current']:
							self.channels['current'].remove(chan)
				elif event == 'KILL':
					nick = args[2]
					if nick == self.nickname:
						raise Exception('KILL')
				elif event == 'MODE' and len(args) == 4:
					nick = args[2]
					if nick == self.nickname:
						mode = args[3][1:]
						if mode == '+r':
							chan = settings.register_chan + '_' + str(random.randint(10,99))
							await self.raw('JOIN ' + chan)
							await self.raw(f'TOPIC {chan} :' + settings.register_chan_topic)
							await self.sendmsg('ChanServ', 'REGISTER ' + chan)
							await self.sendmsg('ChanServ', f'SET {chan} KEEPTOPIC ON')
							await self.sendmsg('ChanServ', f'SET {chan} NOEXPIRE ON')
							await self.sendmsg('ChanServ', f'SET {chan} PERSIST ON')
							await self.sendmsg('ChanServ', f'SET {chan} DESCRIPTION ' + settings.register_chan_topic)
							await self.raw('PART ' + chan)
				elif event in ('NOTICE','PRIVMSG') and len(args) >= 4:
					nick   = args[0].split('!')[1:]
					target = args[2]
					msg    = ' '.join(args[3:])[1:]
					if target == self.nickname:
						for i in ('proxy','proxys','proxies'):
							if i in msg.lower():
								check = [x for x in ('bopm','hopm') if x in line]
								if check:
									error(f'{self.display}\033[93m{check[0].upper()} detected\033[0m')
								else:
									error(self.display + '\033[93mProxy Monitor detected\033[0m')
						for i in ('You must have been using this nick for','You must be connected for','not connected long enough','Please wait', 'You cannot list within the first'):
							if i in msg:
								error(self.display + '\033[31merror\033[0m - delay found', msg)
								break
						if msg[:8] == '\001VERSION':
							version = random.choice(('http://www.mibbit.com ajax IRC Client','mIRC v6.35 Khaled Mardam-Bey','xchat 0.24.1 Linux 2.6.27-8-eeepc i686','rZNC Version 1.0 [02/01/11] - Built from ZNC','thelounge v3.0.0 -- https://thelounge.chat/'))
							await self.raw(f'NOTICE {nick} \001VERSION {version}\001')
						elif '!' not in args[0]:
							if 'dronebl.org/lookup' in msg:
								error(self.display + '\033[93mDroneBL detected\033[0m')
								raise Exception('DroneBL')
							else:
								if [i for i in ('You\'re banned','You are permanently banned','You are banned','You are not welcome','Temporary K-line') if i in msg]:
									raise Exception('K-Lined')
			except (UnicodeDecodeError, UnicodeEncodeError):
				pass
			except Exception as ex:
				error(self.display + '\033[1;31mdisconnected\033[0m', ex)
				break

async def main_b(targets):
	sema = asyncio.BoundedSemaphore(throttle.pthreads) # B O U N D E D   S E M A P H O R E   G A N G
	jobs = list()
	for target in targets:
		jobs.append(asyncio.ensure_future(check_proxy(sema, target)))
	await asyncio.gather(*jobs)

async def main_a(targets):
	sema = asyncio.BoundedSemaphore(throttle.threads) # B O U N D E D   S E M A P H O R E   G A N G
	jobs = list()
	if settings.proxies:
		if settings.proxies_scan:
			proxies = None
			del all_proxies[:len(all_proxies)]
			del good_proxies[:len(good_proxies)]
			while not good_proxies:
				debug('scanning for fresh Socks5 proxies...')
				proxies = get_proxies()
				if proxies:
					debug(f'testing {len(proxies):,} proxies...')
					await main_b(proxies)
					if not good_proxies:
						await asyncio.sleep(300)
				else:
					await asyncio.sleep(300)
			debug(f'found {len(good_proxies):,} proxies')
		elif settings.proxies_local:
			with open('proxies.txt', 'r') as f:
				good_proxies = [line.rstrip() for line in f.readlines() if line]
		else:
			raise SystemExit('error: invalid proxy mode (must use either proxy scanning or local proxies)')
	for target in targets:
		try:
			ipaddress.IPv4Address(target)
		except:
			error('invalid ip address', target)
		else:
			if settings.proxies:
				for proxy in good_proxies: # Todo: we should check if this is empty before running
					jobs.append(asyncio.ensure_future(probe(sema, target, proxy).run()))
			if not settings.proxies_only:
				jobs.append(asyncio.ensure_future(probe(sema, target).run()))
	random.shuffle(jobs)
	await asyncio.gather(*jobs)

# Main
print('#'*56)
print('#{:^54}#'.format(''))
print('#{:^54}#'.format('EFknockr (internet relay chat beacon)'))
print('#{:^54}#'.format('Developed by acidvegas in Python'))
print('#{:^54}#'.format('https://git.acid.vegas/efknockr'))
print('#{:^54}#'.format(''))
print('#'*56)
if True:
	raise SystemExit('those who are not skids may figure out how to use this...') # ;) by removing this you agree to only test this on your own server(s) LOLOLOOL
if settings.proxies:
	try:
		import aiosocks
	except ImportError:
		raise SystemExit('missing required library \'aiosocks\' (https://pypi.org/project/aiosocks/)')
if len(sys.argv) != 2:
	raise SystemExit('error: invalid arguments')
targets_file = sys.argv[1]
if not os.path.isfile(targets_file):
	raise SystemExit('error: invalid file path')
targets = [line.rstrip() for line in open(targets_file).readlines() if line and line not in bad.donotscan]
del targets_file
debug(f'loaded {len(targets):,} targets')
while True:
	asyncio.run(main_a(targets))
	debug('EFknockr has finished knocking!!')
	if not settings.daemon:
		break