600 lines
24 KiB
Python
600 lines
24 KiB
Python
#!/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
|